YES(O(1),O(n^3))

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , +(@x, @y) -> #add(@x, @y)
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m)) }
Weak Trs:
  { #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We add following dependency tuples:

Strict DPs:
  { #abs^#(#0()) -> c_1()
  , #abs^#(#neg(@x)) -> c_2()
  , #abs^#(#pos(@x)) -> c_3()
  , #abs^#(#s(@x)) -> c_4()
  , *^#(@x, @y) -> c_5(#mult^#(@x, @y))
  , +^#(@x, @y) -> c_6(#add^#(@x, @y))
  , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
  , attach#1^#(nil(), @m) -> c_9()
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
  , attach#2^#(nil(), @x, @xs) -> c_11()
  , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
  , lineMult#1^#(nil(), @l) -> c_14()
  , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
  , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
  , makeBase^#(@m) -> c_16(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
  , makeBase#1^#(nil()) -> c_18()
  , mkBase^#(@m) -> c_19(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
  , mkBase#1^#(nil()) -> c_32()
  , matrixMult^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , transAcc#1^#(nil(), @base) -> c_44()
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult'#1^#(nil(), @m2) -> c_24()
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_26(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultList#1^#(nil(), @acc) -> c_28()
  , matrixMultOld^#(@m1, @m2) ->
    c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_45(transpose#2^#(split(@m)), split^#(@m))
  , transpose#1^#(nil(), @m) -> c_46()
  , mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
  , split^#(@m) -> c_37(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
  , split#1^#(nil()) -> c_39()
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
  , split#2^#(nil(), @ls) -> c_41()
  , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
  , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys)))
  , transpose#3^#(nil(), @l) -> c_49()
  , transpose'^#(@m) ->
    c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
  { #mult^#(#0(), #0()) -> c_51()
  , #mult^#(#0(), #neg(@y)) -> c_52()
  , #mult^#(#0(), #pos(@y)) -> c_53()
  , #mult^#(#neg(@x), #0()) -> c_54()
  , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
  , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #0()) -> c_57()
  , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
  , #add^#(#0(), @y) -> c_60()
  , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
  , #add^#(#neg(#s(#s(@x))), @y) ->
    c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
  , #add^#(#pos(#s(#s(@x))), @y) ->
    c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #natmult^#(#0(), @y) -> c_73()
  , #natmult^#(#s(@x), @y) ->
    c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
  , #pred^#(#0()) -> c_65()
  , #pred^#(#neg(#s(@x))) -> c_66()
  , #pred^#(#pos(#s(#0()))) -> c_67()
  , #pred^#(#pos(#s(#s(@x)))) -> c_68()
  , #succ^#(#0()) -> c_69()
  , #succ^#(#neg(#s(#0()))) -> c_70()
  , #succ^#(#neg(#s(#s(@x)))) -> c_71()
  , #succ^#(#pos(#s(@x))) -> c_72()
  , #natadd^#(#0(), @y) -> c_75()
  , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }

and mark the set of starting terms.

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { #abs^#(#0()) -> c_1()
  , #abs^#(#neg(@x)) -> c_2()
  , #abs^#(#pos(@x)) -> c_3()
  , #abs^#(#s(@x)) -> c_4()
  , *^#(@x, @y) -> c_5(#mult^#(@x, @y))
  , +^#(@x, @y) -> c_6(#add^#(@x, @y))
  , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
  , attach#1^#(nil(), @m) -> c_9()
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
  , attach#2^#(nil(), @x, @xs) -> c_11()
  , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
  , lineMult#1^#(nil(), @l) -> c_14()
  , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
  , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
  , makeBase^#(@m) -> c_16(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
  , makeBase#1^#(nil()) -> c_18()
  , mkBase^#(@m) -> c_19(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
  , mkBase#1^#(nil()) -> c_32()
  , matrixMult^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , transAcc#1^#(nil(), @base) -> c_44()
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult'#1^#(nil(), @m2) -> c_24()
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_26(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultList#1^#(nil(), @acc) -> c_28()
  , matrixMultOld^#(@m1, @m2) ->
    c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_45(transpose#2^#(split(@m)), split^#(@m))
  , transpose#1^#(nil(), @m) -> c_46()
  , mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
  , split^#(@m) -> c_37(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
  , split#1^#(nil()) -> c_39()
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
  , split#2^#(nil(), @ls) -> c_41()
  , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
  , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys)))
  , transpose#3^#(nil(), @l) -> c_49()
  , transpose'^#(@m) ->
    c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
  { #mult^#(#0(), #0()) -> c_51()
  , #mult^#(#0(), #neg(@y)) -> c_52()
  , #mult^#(#0(), #pos(@y)) -> c_53()
  , #mult^#(#neg(@x), #0()) -> c_54()
  , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
  , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #0()) -> c_57()
  , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
  , #add^#(#0(), @y) -> c_60()
  , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
  , #add^#(#neg(#s(#s(@x))), @y) ->
    c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
  , #add^#(#pos(#s(#s(@x))), @y) ->
    c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #natmult^#(#0(), @y) -> c_73()
  , #natmult^#(#s(@x), @y) ->
    c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
  , #pred^#(#0()) -> c_65()
  , #pred^#(#neg(#s(@x))) -> c_66()
  , #pred^#(#pos(#s(#0()))) -> c_67()
  , #pred^#(#pos(#s(#s(@x)))) -> c_68()
  , #succ^#(#0()) -> c_69()
  , #succ^#(#neg(#s(#0()))) -> c_70()
  , #succ^#(#neg(#s(#s(@x)))) -> c_71()
  , #succ^#(#pos(#s(@x))) -> c_72()
  , #natadd^#(#0(), @y) -> c_75()
  , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

Consider the dependency graph

  1: #abs^#(#0()) -> c_1()
  
  2: #abs^#(#neg(@x)) -> c_2()
  
  3: #abs^#(#pos(@x)) -> c_3()
  
  4: #abs^#(#s(@x)) -> c_4()
  
  5: *^#(@x, @y) -> c_5(#mult^#(@x, @y))
     -->_1 #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y)) :59
     -->_1 #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y)) :58
     -->_1 #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y)) :56
     -->_1 #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y)) :55
     -->_1 #mult^#(#pos(@x), #0()) -> c_57() :57
     -->_1 #mult^#(#neg(@x), #0()) -> c_54() :54
     -->_1 #mult^#(#0(), #pos(@y)) -> c_53() :53
     -->_1 #mult^#(#0(), #neg(@y)) -> c_52() :52
     -->_1 #mult^#(#0(), #0()) -> c_51() :51
  
  6: +^#(@x, @y) -> c_6(#add^#(@x, @y))
     -->_1 #add^#(#pos(#s(#s(@x))), @y) ->
           c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
     -->_1 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63
     -->_1 #add^#(#neg(#s(#s(@x))), @y) ->
           c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :62
     -->_1 #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) :61
     -->_1 #add^#(#0(), @y) -> c_60() :60
  
  7: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
     -->_1 attach#1^#(::(@x, @xs), @m) ->
           c_8(attach#2^#(@m, @x, @xs)) :8
     -->_1 attach#1^#(nil(), @m) -> c_9() :9
  
  8: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
     -->_1 attach#2^#(::(@l, @ls), @x, @xs) ->
           c_10(attach^#(@xs, @ls)) :10
     -->_1 attach#2^#(nil(), @x, @xs) -> c_11() :11
  
  9: attach#1^#(nil(), @m) -> c_9()
  
  10: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
     -->_1 attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) :7
  
  11: attach#2^#(nil(), @x, @xs) -> c_11()
  
  12: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
     -->_1 lineMult#1^#(::(@x, @xs), @l) ->
           c_13(mult^#(@l, @x), lineMult^#(@l, @xs)) :13
     -->_1 lineMult#1^#(nil(), @l) -> c_14() :14
  
  13: lineMult#1^#(::(@x, @xs), @l) ->
      c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
     -->_1 mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) :15
     -->_2 lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) :12
  
  14: lineMult#1^#(nil(), @l) -> c_14()
  
  15: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
     -->_1 mult#1^#(nil(), @l2) -> c_34(#abs^#(#0())) :17
     -->_1 mult#1^#(::(@x, @xs), @l2) ->
           c_33(mult#2^#(@l2, @x, @xs)) :16
  
  16: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
     -->_1 mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0())) :40
     -->_1 mult#2^#(::(@y, @ys), @x, @xs) ->
           c_35(+^#(*(@x, @y), mult(@xs, @ys)),
                *^#(@x, @y),
                mult^#(@xs, @ys)) :39
  
  17: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
     -->_1 #abs^#(#0()) -> c_1() :1
  
  18: makeBase^#(@m) -> c_16(makeBase#1^#(@m))
     -->_1 makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l)) :19
     -->_1 makeBase#1^#(nil()) -> c_18() :20
  
  19: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
     -->_1 mkBase^#(@m) -> c_19(mkBase#1^#(@m)) :21
  
  20: makeBase#1^#(nil()) -> c_18()
  
  21: mkBase^#(@m) -> c_19(mkBase#1^#(@m))
     -->_1 mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m')) :22
     -->_1 mkBase#1^#(nil()) -> c_32() :23
  
  22: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
     -->_1 mkBase^#(@m) -> c_19(mkBase#1^#(@m)) :21
  
  23: mkBase#1^#(nil()) -> c_32()
  
  24: matrixMult^#(@m1, @m2) ->
      c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
           transAcc^#(@m2, makeBase(@m2)),
           makeBase^#(@m2))
     -->_2 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26
     -->_1 matrixMult'^#(@m1, @m2) ->
           c_22(matrixMult'#1^#(@m1, @m2)) :25
     -->_3 makeBase^#(@m) -> c_16(makeBase#1^#(@m)) :18
  
  25: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
     -->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
           c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :29
     -->_1 matrixMult'#1^#(nil(), @m2) -> c_24() :30
  
  26: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
     -->_1 transAcc#1^#(::(@l, @m'), @base) ->
           c_43(attach^#(@l, transAcc(@m', @base)),
                transAcc^#(@m', @base)) :27
     -->_1 transAcc#1^#(nil(), @base) -> c_44() :28
  
  27: transAcc#1^#(::(@l, @m'), @base) ->
      c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
     -->_2 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26
     -->_1 attach^#(@line, @m) -> c_7(attach#1^#(@line, @m)) :7
  
  28: transAcc#1^#(nil(), @base) -> c_44()
  
  29: matrixMult'#1^#(::(@l, @ls), @m2) ->
      c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
     -->_2 matrixMult'^#(@m1, @m2) ->
           c_22(matrixMult'#1^#(@m1, @m2)) :25
     -->_1 lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l)) :12
  
  30: matrixMult'#1^#(nil(), @m2) -> c_24()
  
  31: matrixMult3^#(@m1, @m2, @m3) ->
      c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
           matrixMult^#(@m1, @m2))
     -->_2 matrixMult^#(@m1, @m2) ->
           c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
                transAcc^#(@m2, makeBase(@m2)),
                makeBase^#(@m2)) :24
     -->_1 matrixMult^#(@m1, @m2) ->
           c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
                transAcc^#(@m2, makeBase(@m2)),
                makeBase^#(@m2)) :24
  
  32: matrixMultList^#(@acc, @mm) ->
      c_26(matrixMultList#1^#(@mm, @acc))
     -->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
           c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
                matrixMult^#(@acc, @m)) :33
     -->_1 matrixMultList#1^#(nil(), @acc) -> c_28() :34
  
  33: matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
           matrixMult^#(@acc, @m))
     -->_1 matrixMultList^#(@acc, @mm) ->
           c_26(matrixMultList#1^#(@mm, @acc)) :32
     -->_2 matrixMult^#(@m1, @m2) ->
           c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
                transAcc^#(@m2, makeBase(@m2)),
                makeBase^#(@m2)) :24
  
  34: matrixMultList#1^#(nil(), @acc) -> c_28()
  
  35: matrixMultOld^#(@m1, @m2) ->
      c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
     -->_2 transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) :36
     -->_1 matrixMult'^#(@m1, @m2) ->
           c_22(matrixMult'#1^#(@m1, @m2)) :25
  
  36: transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
     -->_1 transpose#1^#(::(@xs, @xss), @m) ->
           c_45(transpose#2^#(split(@m)), split^#(@m)) :37
     -->_1 transpose#1^#(nil(), @m) -> c_46() :38
  
  37: transpose#1^#(::(@xs, @xss), @m) ->
      c_45(transpose#2^#(split(@m)), split^#(@m))
     -->_1 transpose#2^#(tuple#2(@l, @m')) ->
           c_47(transpose#3^#(@m', @l)) :47
     -->_2 split^#(@m) -> c_37(split#1^#(@m)) :41
  
  38: transpose#1^#(nil(), @m) -> c_46()
  
  39: mult#2^#(::(@y, @ys), @x, @xs) ->
      c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
     -->_3 mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2)) :15
     -->_1 +^#(@x, @y) -> c_6(#add^#(@x, @y)) :6
     -->_2 *^#(@x, @y) -> c_5(#mult^#(@x, @y)) :5
  
  40: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
     -->_1 #abs^#(#0()) -> c_1() :1
  
  41: split^#(@m) -> c_37(split#1^#(@m))
     -->_1 split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls)) :42
     -->_1 split#1^#(nil()) -> c_39() :43
  
  42: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
     -->_1 split#2^#(::(@x, @xs), @ls) ->
           c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) :44
     -->_1 split#2^#(nil(), @ls) -> c_41() :45
  
  43: split#1^#(nil()) -> c_39()
  
  44: split#2^#(::(@x, @xs), @ls) ->
      c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
     -->_1 split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42() :46
     -->_2 split^#(@m) -> c_37(split#1^#(@m)) :41
  
  45: split#2^#(nil(), @ls) -> c_41()
  
  46: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
  
  47: transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
     -->_1 transpose#3^#(::(@y, @ys), @l) ->
           c_48(transpose^#(::(@y, @ys))) :48
     -->_1 transpose#3^#(nil(), @l) -> c_49() :49
  
  48: transpose#3^#(::(@y, @ys), @l) ->
      c_48(transpose^#(::(@y, @ys)))
     -->_1 transpose^#(@m) -> c_30(transpose#1^#(@m, @m)) :36
  
  49: transpose#3^#(nil(), @l) -> c_49()
  
  50: transpose'^#(@m) ->
      c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
     -->_1 transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base)) :26
     -->_2 makeBase^#(@m) -> c_16(makeBase#1^#(@m)) :18
  
  51: #mult^#(#0(), #0()) -> c_51()
  
  52: #mult^#(#0(), #neg(@y)) -> c_52()
  
  53: #mult^#(#0(), #pos(@y)) -> c_53()
  
  54: #mult^#(#neg(@x), #0()) -> c_54()
  
  55: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
     -->_1 #natmult^#(#s(@x), @y) ->
           c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66
     -->_1 #natmult^#(#0(), @y) -> c_73() :65
  
  56: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
     -->_1 #natmult^#(#s(@x), @y) ->
           c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66
     -->_1 #natmult^#(#0(), @y) -> c_73() :65
  
  57: #mult^#(#pos(@x), #0()) -> c_57()
  
  58: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
     -->_1 #natmult^#(#s(@x), @y) ->
           c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66
     -->_1 #natmult^#(#0(), @y) -> c_73() :65
  
  59: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
     -->_1 #natmult^#(#s(@x), @y) ->
           c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66
     -->_1 #natmult^#(#0(), @y) -> c_73() :65
  
  60: #add^#(#0(), @y) -> c_60()
  
  61: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
     -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70
     -->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69
     -->_1 #pred^#(#neg(#s(@x))) -> c_66() :68
     -->_1 #pred^#(#0()) -> c_65() :67
  
  62: #add^#(#neg(#s(#s(@x))), @y) ->
      c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
     -->_2 #add^#(#pos(#s(#s(@x))), @y) ->
           c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
     -->_2 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63
     -->_1 #pred^#(#pos(#s(#s(@x)))) -> c_68() :70
     -->_1 #pred^#(#pos(#s(#0()))) -> c_67() :69
     -->_1 #pred^#(#neg(#s(@x))) -> c_66() :68
     -->_1 #pred^#(#0()) -> c_65() :67
  
  63: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
     -->_1 #succ^#(#pos(#s(@x))) -> c_72() :74
     -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73
     -->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72
     -->_1 #succ^#(#0()) -> c_69() :71
  
  64: #add^#(#pos(#s(#s(@x))), @y) ->
      c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
     -->_1 #succ^#(#pos(#s(@x))) -> c_72() :74
     -->_1 #succ^#(#neg(#s(#s(@x)))) -> c_71() :73
     -->_1 #succ^#(#neg(#s(#0()))) -> c_70() :72
     -->_1 #succ^#(#0()) -> c_69() :71
     -->_2 #add^#(#pos(#s(#s(@x))), @y) ->
           c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) :64
     -->_2 #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y)) :63
  
  65: #natmult^#(#0(), @y) -> c_73()
  
  66: #natmult^#(#s(@x), @y) ->
      c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
     -->_1 #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) :76
     -->_1 #natadd^#(#0(), @y) -> c_75() :75
     -->_2 #natmult^#(#s(@x), @y) ->
           c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y)) :66
     -->_2 #natmult^#(#0(), @y) -> c_73() :65
  
  67: #pred^#(#0()) -> c_65()
  
  68: #pred^#(#neg(#s(@x))) -> c_66()
  
  69: #pred^#(#pos(#s(#0()))) -> c_67()
  
  70: #pred^#(#pos(#s(#s(@x)))) -> c_68()
  
  71: #succ^#(#0()) -> c_69()
  
  72: #succ^#(#neg(#s(#0()))) -> c_70()
  
  73: #succ^#(#neg(#s(#s(@x)))) -> c_71()
  
  74: #succ^#(#pos(#s(@x))) -> c_72()
  
  75: #natadd^#(#0(), @y) -> c_75()
  
  76: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y))
     -->_1 #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) :76
     -->_1 #natadd^#(#0(), @y) -> c_75() :75
  

Following roots of the dependency graph are removed, as the
considered set of starting terms is closed under reduction with
respect to these rules (modulo compound contexts).

  { #abs^#(#neg(@x)) -> c_2()
  , #abs^#(#pos(@x)) -> c_3()
  , #abs^#(#s(@x)) -> c_4() }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { #abs^#(#0()) -> c_1()
  , *^#(@x, @y) -> c_5(#mult^#(@x, @y))
  , +^#(@x, @y) -> c_6(#add^#(@x, @y))
  , attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
  , attach#1^#(nil(), @m) -> c_9()
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
  , attach#2^#(nil(), @x, @xs) -> c_11()
  , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
  , lineMult#1^#(nil(), @l) -> c_14()
  , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
  , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
  , makeBase^#(@m) -> c_16(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
  , makeBase#1^#(nil()) -> c_18()
  , mkBase^#(@m) -> c_19(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
  , mkBase#1^#(nil()) -> c_32()
  , matrixMult^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , transAcc#1^#(nil(), @base) -> c_44()
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult'#1^#(nil(), @m2) -> c_24()
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_26(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultList#1^#(nil(), @acc) -> c_28()
  , matrixMultOld^#(@m1, @m2) ->
    c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_45(transpose#2^#(split(@m)), split^#(@m))
  , transpose#1^#(nil(), @m) -> c_46()
  , mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
  , split^#(@m) -> c_37(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
  , split#1^#(nil()) -> c_39()
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
  , split#2^#(nil(), @ls) -> c_41()
  , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
  , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys)))
  , transpose#3^#(nil(), @l) -> c_49()
  , transpose'^#(@m) ->
    c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
  { #mult^#(#0(), #0()) -> c_51()
  , #mult^#(#0(), #neg(@y)) -> c_52()
  , #mult^#(#0(), #pos(@y)) -> c_53()
  , #mult^#(#neg(@x), #0()) -> c_54()
  , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
  , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #0()) -> c_57()
  , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
  , #add^#(#0(), @y) -> c_60()
  , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
  , #add^#(#neg(#s(#s(@x))), @y) ->
    c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
  , #add^#(#pos(#s(#s(@x))), @y) ->
    c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #natmult^#(#0(), @y) -> c_73()
  , #natmult^#(#s(@x), @y) ->
    c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
  , #pred^#(#0()) -> c_65()
  , #pred^#(#neg(#s(@x))) -> c_66()
  , #pred^#(#pos(#s(#0()))) -> c_67()
  , #pred^#(#pos(#s(#s(@x)))) -> c_68()
  , #succ^#(#0()) -> c_69()
  , #succ^#(#neg(#s(#0()))) -> c_70()
  , #succ^#(#neg(#s(#s(@x)))) -> c_71()
  , #succ^#(#pos(#s(@x))) -> c_72()
  , #natadd^#(#0(), @y) -> c_75()
  , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We estimate the number of application of
{1,2,3,6,8,11,17,20,25,27,31,35,40,42,43,46} by applications of
Pre({1,2,3,6,8,11,17,20,25,27,31,35,40,42,43,46}) =
{4,5,9,14,15,18,22,23,29,33,36,37,38,39,41,44}. Here rules are
labeled as follows:

  DPs:
    { 1: #abs^#(#0()) -> c_1()
    , 2: *^#(@x, @y) -> c_5(#mult^#(@x, @y))
    , 3: +^#(@x, @y) -> c_6(#add^#(@x, @y))
    , 4: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
    , 5: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
    , 6: attach#1^#(nil(), @m) -> c_9()
    , 7: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
    , 8: attach#2^#(nil(), @x, @xs) -> c_11()
    , 9: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
    , 10: lineMult#1^#(::(@x, @xs), @l) ->
          c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
    , 11: lineMult#1^#(nil(), @l) -> c_14()
    , 12: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
    , 13: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
    , 14: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
    , 15: makeBase^#(@m) -> c_16(makeBase#1^#(@m))
    , 16: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
    , 17: makeBase#1^#(nil()) -> c_18()
    , 18: mkBase^#(@m) -> c_19(mkBase#1^#(@m))
    , 19: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
    , 20: mkBase#1^#(nil()) -> c_32()
    , 21: matrixMult^#(@m1, @m2) ->
          c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
               transAcc^#(@m2, makeBase(@m2)),
               makeBase^#(@m2))
    , 22: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
    , 23: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
    , 24: transAcc#1^#(::(@l, @m'), @base) ->
          c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
    , 25: transAcc#1^#(nil(), @base) -> c_44()
    , 26: matrixMult'#1^#(::(@l, @ls), @m2) ->
          c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
    , 27: matrixMult'#1^#(nil(), @m2) -> c_24()
    , 28: matrixMult3^#(@m1, @m2, @m3) ->
          c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
               matrixMult^#(@m1, @m2))
    , 29: matrixMultList^#(@acc, @mm) ->
          c_26(matrixMultList#1^#(@mm, @acc))
    , 30: matrixMultList#1^#(::(@m, @ms), @acc) ->
          c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
               matrixMult^#(@acc, @m))
    , 31: matrixMultList#1^#(nil(), @acc) -> c_28()
    , 32: matrixMultOld^#(@m1, @m2) ->
          c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
    , 33: transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
    , 34: transpose#1^#(::(@xs, @xss), @m) ->
          c_45(transpose#2^#(split(@m)), split^#(@m))
    , 35: transpose#1^#(nil(), @m) -> c_46()
    , 36: mult#2^#(::(@y, @ys), @x, @xs) ->
          c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
    , 37: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
    , 38: split^#(@m) -> c_37(split#1^#(@m))
    , 39: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
    , 40: split#1^#(nil()) -> c_39()
    , 41: split#2^#(::(@x, @xs), @ls) ->
          c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
    , 42: split#2^#(nil(), @ls) -> c_41()
    , 43: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
    , 44: transpose#2^#(tuple#2(@l, @m')) ->
          c_47(transpose#3^#(@m', @l))
    , 45: transpose#3^#(::(@y, @ys), @l) ->
          c_48(transpose^#(::(@y, @ys)))
    , 46: transpose#3^#(nil(), @l) -> c_49()
    , 47: transpose'^#(@m) ->
          c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
    , 48: #mult^#(#0(), #0()) -> c_51()
    , 49: #mult^#(#0(), #neg(@y)) -> c_52()
    , 50: #mult^#(#0(), #pos(@y)) -> c_53()
    , 51: #mult^#(#neg(@x), #0()) -> c_54()
    , 52: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
    , 53: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
    , 54: #mult^#(#pos(@x), #0()) -> c_57()
    , 55: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
    , 56: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
    , 57: #add^#(#0(), @y) -> c_60()
    , 58: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
    , 59: #add^#(#neg(#s(#s(@x))), @y) ->
          c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
    , 60: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
    , 61: #add^#(#pos(#s(#s(@x))), @y) ->
          c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
    , 62: #natmult^#(#0(), @y) -> c_73()
    , 63: #natmult^#(#s(@x), @y) ->
          c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
    , 64: #pred^#(#0()) -> c_65()
    , 65: #pred^#(#neg(#s(@x))) -> c_66()
    , 66: #pred^#(#pos(#s(#0()))) -> c_67()
    , 67: #pred^#(#pos(#s(#s(@x)))) -> c_68()
    , 68: #succ^#(#0()) -> c_69()
    , 69: #succ^#(#neg(#s(#0()))) -> c_70()
    , 70: #succ^#(#neg(#s(#s(@x)))) -> c_71()
    , 71: #succ^#(#pos(#s(@x))) -> c_72()
    , 72: #natadd^#(#0(), @y) -> c_75()
    , 73: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
  , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
  , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
  , makeBase^#(@m) -> c_16(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
  , mkBase^#(@m) -> c_19(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
  , matrixMult^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_26(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_45(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
  , split^#(@m) -> c_37(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys)))
  , transpose'^#(@m) ->
    c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
  { #abs^#(#0()) -> c_1()
  , *^#(@x, @y) -> c_5(#mult^#(@x, @y))
  , #mult^#(#0(), #0()) -> c_51()
  , #mult^#(#0(), #neg(@y)) -> c_52()
  , #mult^#(#0(), #pos(@y)) -> c_53()
  , #mult^#(#neg(@x), #0()) -> c_54()
  , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
  , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #0()) -> c_57()
  , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
  , +^#(@x, @y) -> c_6(#add^#(@x, @y))
  , #add^#(#0(), @y) -> c_60()
  , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
  , #add^#(#neg(#s(#s(@x))), @y) ->
    c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
  , #add^#(#pos(#s(#s(@x))), @y) ->
    c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , attach#1^#(nil(), @m) -> c_9()
  , attach#2^#(nil(), @x, @xs) -> c_11()
  , lineMult#1^#(nil(), @l) -> c_14()
  , makeBase#1^#(nil()) -> c_18()
  , mkBase#1^#(nil()) -> c_32()
  , transAcc#1^#(nil(), @base) -> c_44()
  , matrixMult'#1^#(nil(), @m2) -> c_24()
  , matrixMultList#1^#(nil(), @acc) -> c_28()
  , transpose#1^#(nil(), @m) -> c_46()
  , split#1^#(nil()) -> c_39()
  , split#2^#(nil(), @ls) -> c_41()
  , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
  , transpose#3^#(nil(), @l) -> c_49()
  , #natmult^#(#0(), @y) -> c_73()
  , #natmult^#(#s(@x), @y) ->
    c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
  , #pred^#(#0()) -> c_65()
  , #pred^#(#neg(#s(@x))) -> c_66()
  , #pred^#(#pos(#s(#0()))) -> c_67()
  , #pred^#(#pos(#s(#s(@x)))) -> c_68()
  , #succ^#(#0()) -> c_69()
  , #succ^#(#neg(#s(#0()))) -> c_70()
  , #succ^#(#neg(#s(#s(@x)))) -> c_71()
  , #succ^#(#pos(#s(@x))) -> c_72()
  , #natadd^#(#0(), @y) -> c_75()
  , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We estimate the number of application of {8,25} by applications of
Pre({8,25}) = {6,7}. Here rules are labeled as follows:

  DPs:
    { 1: attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
    , 2: attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
    , 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
    , 4: lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
    , 5: lineMult#1^#(::(@x, @xs), @l) ->
         c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
    , 6: mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
    , 7: mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
    , 8: mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
    , 9: makeBase^#(@m) -> c_16(makeBase#1^#(@m))
    , 10: makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
    , 11: mkBase^#(@m) -> c_19(mkBase#1^#(@m))
    , 12: mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
    , 13: matrixMult^#(@m1, @m2) ->
          c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
               transAcc^#(@m2, makeBase(@m2)),
               makeBase^#(@m2))
    , 14: matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
    , 15: transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
    , 16: transAcc#1^#(::(@l, @m'), @base) ->
          c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
    , 17: matrixMult'#1^#(::(@l, @ls), @m2) ->
          c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
    , 18: matrixMult3^#(@m1, @m2, @m3) ->
          c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
               matrixMult^#(@m1, @m2))
    , 19: matrixMultList^#(@acc, @mm) ->
          c_26(matrixMultList#1^#(@mm, @acc))
    , 20: matrixMultList#1^#(::(@m, @ms), @acc) ->
          c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
               matrixMult^#(@acc, @m))
    , 21: matrixMultOld^#(@m1, @m2) ->
          c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
    , 22: transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
    , 23: transpose#1^#(::(@xs, @xss), @m) ->
          c_45(transpose#2^#(split(@m)), split^#(@m))
    , 24: mult#2^#(::(@y, @ys), @x, @xs) ->
          c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
    , 25: mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
    , 26: split^#(@m) -> c_37(split#1^#(@m))
    , 27: split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
    , 28: split#2^#(::(@x, @xs), @ls) ->
          c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
    , 29: transpose#2^#(tuple#2(@l, @m')) ->
          c_47(transpose#3^#(@m', @l))
    , 30: transpose#3^#(::(@y, @ys), @l) ->
          c_48(transpose^#(::(@y, @ys)))
    , 31: transpose'^#(@m) ->
          c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))
    , 32: #abs^#(#0()) -> c_1()
    , 33: *^#(@x, @y) -> c_5(#mult^#(@x, @y))
    , 34: #mult^#(#0(), #0()) -> c_51()
    , 35: #mult^#(#0(), #neg(@y)) -> c_52()
    , 36: #mult^#(#0(), #pos(@y)) -> c_53()
    , 37: #mult^#(#neg(@x), #0()) -> c_54()
    , 38: #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
    , 39: #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
    , 40: #mult^#(#pos(@x), #0()) -> c_57()
    , 41: #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
    , 42: #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
    , 43: +^#(@x, @y) -> c_6(#add^#(@x, @y))
    , 44: #add^#(#0(), @y) -> c_60()
    , 45: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
    , 46: #add^#(#neg(#s(#s(@x))), @y) ->
          c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
    , 47: #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
    , 48: #add^#(#pos(#s(#s(@x))), @y) ->
          c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
    , 49: attach#1^#(nil(), @m) -> c_9()
    , 50: attach#2^#(nil(), @x, @xs) -> c_11()
    , 51: lineMult#1^#(nil(), @l) -> c_14()
    , 52: makeBase#1^#(nil()) -> c_18()
    , 53: mkBase#1^#(nil()) -> c_32()
    , 54: transAcc#1^#(nil(), @base) -> c_44()
    , 55: matrixMult'#1^#(nil(), @m2) -> c_24()
    , 56: matrixMultList#1^#(nil(), @acc) -> c_28()
    , 57: transpose#1^#(nil(), @m) -> c_46()
    , 58: split#1^#(nil()) -> c_39()
    , 59: split#2^#(nil(), @ls) -> c_41()
    , 60: split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
    , 61: transpose#3^#(nil(), @l) -> c_49()
    , 62: #natmult^#(#0(), @y) -> c_73()
    , 63: #natmult^#(#s(@x), @y) ->
          c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
    , 64: #pred^#(#0()) -> c_65()
    , 65: #pred^#(#neg(#s(@x))) -> c_66()
    , 66: #pred^#(#pos(#s(#0()))) -> c_67()
    , 67: #pred^#(#pos(#s(#s(@x)))) -> c_68()
    , 68: #succ^#(#0()) -> c_69()
    , 69: #succ^#(#neg(#s(#0()))) -> c_70()
    , 70: #succ^#(#neg(#s(#s(@x)))) -> c_71()
    , 71: #succ^#(#pos(#s(@x))) -> c_72()
    , 72: #natadd^#(#0(), @y) -> c_75()
    , 73: #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
  , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
  , makeBase^#(@m) -> c_16(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
  , mkBase^#(@m) -> c_19(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
  , matrixMult^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_26(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_45(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , split^#(@m) -> c_37(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys)))
  , transpose'^#(@m) ->
    c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak DPs:
  { #abs^#(#0()) -> c_1()
  , *^#(@x, @y) -> c_5(#mult^#(@x, @y))
  , #mult^#(#0(), #0()) -> c_51()
  , #mult^#(#0(), #neg(@y)) -> c_52()
  , #mult^#(#0(), #pos(@y)) -> c_53()
  , #mult^#(#neg(@x), #0()) -> c_54()
  , #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
  , #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #0()) -> c_57()
  , #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
  , #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
  , +^#(@x, @y) -> c_6(#add^#(@x, @y))
  , #add^#(#0(), @y) -> c_60()
  , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
  , #add^#(#neg(#s(#s(@x))), @y) ->
    c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
  , #add^#(#pos(#s(#s(@x))), @y) ->
    c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
  , attach#1^#(nil(), @m) -> c_9()
  , attach#2^#(nil(), @x, @xs) -> c_11()
  , lineMult#1^#(nil(), @l) -> c_14()
  , mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
  , makeBase#1^#(nil()) -> c_18()
  , mkBase#1^#(nil()) -> c_32()
  , transAcc#1^#(nil(), @base) -> c_44()
  , matrixMult'#1^#(nil(), @m2) -> c_24()
  , matrixMultList#1^#(nil(), @acc) -> c_28()
  , transpose#1^#(nil(), @m) -> c_46()
  , mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
  , split#1^#(nil()) -> c_39()
  , split#2^#(nil(), @ls) -> c_41()
  , split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
  , transpose#3^#(nil(), @l) -> c_49()
  , #natmult^#(#0(), @y) -> c_73()
  , #natmult^#(#s(@x), @y) ->
    c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
  , #pred^#(#0()) -> c_65()
  , #pred^#(#neg(#s(@x))) -> c_66()
  , #pred^#(#pos(#s(#0()))) -> c_67()
  , #pred^#(#pos(#s(#s(@x)))) -> c_68()
  , #succ^#(#0()) -> c_69()
  , #succ^#(#neg(#s(#0()))) -> c_70()
  , #succ^#(#neg(#s(#s(@x)))) -> c_71()
  , #succ^#(#pos(#s(@x))) -> c_72()
  , #natadd^#(#0(), @y) -> c_75()
  , #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ #abs^#(#0()) -> c_1()
, *^#(@x, @y) -> c_5(#mult^#(@x, @y))
, #mult^#(#0(), #0()) -> c_51()
, #mult^#(#0(), #neg(@y)) -> c_52()
, #mult^#(#0(), #pos(@y)) -> c_53()
, #mult^#(#neg(@x), #0()) -> c_54()
, #mult^#(#neg(@x), #neg(@y)) -> c_55(#natmult^#(@x, @y))
, #mult^#(#neg(@x), #pos(@y)) -> c_56(#natmult^#(@x, @y))
, #mult^#(#pos(@x), #0()) -> c_57()
, #mult^#(#pos(@x), #neg(@y)) -> c_58(#natmult^#(@x, @y))
, #mult^#(#pos(@x), #pos(@y)) -> c_59(#natmult^#(@x, @y))
, +^#(@x, @y) -> c_6(#add^#(@x, @y))
, #add^#(#0(), @y) -> c_60()
, #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y))
, #add^#(#neg(#s(#s(@x))), @y) ->
  c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, #add^#(#pos(#s(#0())), @y) -> c_63(#succ^#(@y))
, #add^#(#pos(#s(#s(@x))), @y) ->
  c_64(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y))
, attach#1^#(nil(), @m) -> c_9()
, attach#2^#(nil(), @x, @xs) -> c_11()
, lineMult#1^#(nil(), @l) -> c_14()
, mult#1^#(nil(), @l2) -> c_34(#abs^#(#0()))
, makeBase#1^#(nil()) -> c_18()
, mkBase#1^#(nil()) -> c_32()
, transAcc#1^#(nil(), @base) -> c_44()
, matrixMult'#1^#(nil(), @m2) -> c_24()
, matrixMultList#1^#(nil(), @acc) -> c_28()
, transpose#1^#(nil(), @m) -> c_46()
, mult#2^#(nil(), @x, @xs) -> c_36(#abs^#(#0()))
, split#1^#(nil()) -> c_39()
, split#2^#(nil(), @ls) -> c_41()
, split#3^#(tuple#2(@ys, @m'), @x, @xs) -> c_42()
, transpose#3^#(nil(), @l) -> c_49()
, #natmult^#(#0(), @y) -> c_73()
, #natmult^#(#s(@x), @y) ->
  c_74(#natadd^#(@y, #natmult(@x, @y)), #natmult^#(@x, @y))
, #pred^#(#0()) -> c_65()
, #pred^#(#neg(#s(@x))) -> c_66()
, #pred^#(#pos(#s(#0()))) -> c_67()
, #pred^#(#pos(#s(#s(@x)))) -> c_68()
, #succ^#(#0()) -> c_69()
, #succ^#(#neg(#s(#0()))) -> c_70()
, #succ^#(#neg(#s(#s(@x)))) -> c_71()
, #succ^#(#pos(#s(@x))) -> c_72()
, #natadd^#(#0(), @y) -> c_75()
, #natadd^#(#s(@x), @y) -> c_76(#natadd^#(@x, @y)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { attach^#(@line, @m) -> c_7(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_8(attach#2^#(@m, @x, @xs))
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_10(attach^#(@xs, @ls))
  , lineMult^#(@l, @m2) -> c_12(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_13(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_15(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_33(mult#2^#(@l2, @x, @xs))
  , makeBase^#(@m) -> c_16(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_17(mkBase^#(@l))
  , mkBase^#(@m) -> c_19(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_31(mkBase^#(@m'))
  , matrixMult^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_22(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_21(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_43(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_23(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_25(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_26(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_27(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_29(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_30(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_45(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , split^#(@m) -> c_37(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_38(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_47(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_48(transpose^#(::(@y, @ys)))
  , transpose'^#(@m) ->
    c_50(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { mult#2^#(::(@y, @ys), @x, @xs) ->
    c_35(+^#(*(@x, @y), mult(@xs, @ys)), *^#(@x, @y), mult^#(@xs, @ys))
  , split#2^#(::(@x, @xs), @ls) ->
    c_40(split#3^#(split(@ls), @x, @xs), split^#(@ls)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs))
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls))
  , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_5(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs))
  , makeBase^#(@m) -> c_8(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l))
  , mkBase^#(@m) -> c_10(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m'))
  , matrixMult^#(@m1, @m2) ->
    c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_17(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_18(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_19(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_21(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_22(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys))
  , split^#(@m) -> c_24(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys)))
  , transpose'^#(@m) ->
    c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , matrixMult3(@m1, @m2, @m3) ->
    matrixMult(matrixMult(@m1, @m2), @m3)
  , matrixMultList(@acc, @mm) -> matrixMultList#1(@mm, @acc)
  , matrixMultList#1(::(@m, @ms), @acc) ->
    matrixMultList(matrixMult(@acc, @m), @ms)
  , matrixMultList#1(nil(), @acc) -> @acc
  , matrixMultOld(@m1, @m2) -> matrixMult'(@m1, transpose(@m2))
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , transpose'(@m) -> transAcc(@m, makeBase(@m))
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We replace rewrite rules by usable rules:

  Weak Usable Rules:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs))
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls))
  , lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_5(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs))
  , makeBase^#(@m) -> c_8(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l))
  , mkBase^#(@m) -> c_10(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m'))
  , matrixMult^#(@m1, @m2) ->
    c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_17(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_18(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_19(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_21(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_22(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys))
  , split^#(@m) -> c_24(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) -> c_28(transpose^#(::(@y, @ys)))
  , transpose'^#(@m) ->
    c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.

DPs:
  { 1: attach^#(@line, @m) -> c_1(attach#1^#(@line, @m))
  , 18: matrixMultList^#(@acc, @mm) ->
        c_18(matrixMultList#1^#(@mm, @acc))
  , 20: matrixMultOld^#(@m1, @m2) ->
        c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , 29: transpose'^#(@m) ->
        c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Trs:
  { *(@x, @y) -> #mult(@x, @y)
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , mkBase#1(nil()) -> nil()
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1, 2}, Uargs(c_6) = {1},
    Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1},
    Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1, 2, 3},
    Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1, 2},
    Uargs(c_16) = {1, 2}, Uargs(c_17) = {1, 2}, Uargs(c_18) = {1},
    Uargs(c_19) = {1, 2}, Uargs(c_20) = {1, 2}, Uargs(c_21) = {1},
    Uargs(c_22) = {1, 2}, Uargs(c_23) = {1}, Uargs(c_24) = {1},
    Uargs(c_25) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1},
    Uargs(c_28) = {1}, Uargs(c_29) = {1, 2}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA).
  
                            [#0] = [0]
                                      
                      [#abs](x1) = [0]
                                      
                      [#neg](x1) = [1] x1 + [1]
                                               
                      [#pos](x1) = [0]
                                      
                        [#s](x1) = [0]
                                      
                     [*](x1, x2) = [1]
                                      
                 [#mult](x1, x2) = [0]
                                      
                     [+](x1, x2) = [1] x1 + [0]
                                               
                  [#add](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                [attach](x1, x2) = [0]
                                      
              [attach#1](x1, x2) = [1] x1 + [1]
                                               
                    [::](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
          [attach#2](x1, x2, x3) = [0]
                                      
                           [nil] = [0]
                                      
              [lineMult](x1, x2) = [1] x2 + [1]
                                               
            [lineMult#1](x1, x2) = [0]
                                      
                  [mult](x1, x2) = [1]
                                      
                  [makeBase](x1) = [0]
                                      
                [makeBase#1](x1) = [1] x1 + [1]
                                               
                    [mkBase](x1) = [0]
                                      
            [matrixMult](x1, x2) = [1] x1 + [0]
                                               
              [transAcc](x1, x2) = [0]
                                      
           [matrixMult'](x1, x2) = [1]
                                      
         [matrixMult'#1](x1, x2) = [0]
                                      
                 [transpose](x1) = [0]
                                      
                  [mkBase#1](x1) = [1]
                                      
                [mult#1](x1, x2) = [0]
                                      
            [mult#2](x1, x2, x3) = [0]
                                      
                     [split](x1) = [0]
                                      
                   [split#1](x1) = [0]
                                      
               [split#2](x1, x2) = [0]
                                      
               [tuple#2](x1, x2) = [0]
                                      
           [split#3](x1, x2, x3) = [0]
                                      
            [transAcc#1](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
           [transpose#1](x1, x2) = [1]
                                      
               [transpose#2](x1) = [0]
                                      
           [transpose#3](x1, x2) = [0]
                                      
                     [#pred](x1) = [0]
                                      
                     [#succ](x1) = [0]
                                      
              [#natmult](x1, x2) = [0]
                                      
               [#natadd](x1, x2) = [0]
                                      
                    [#abs^#](x1) = [0]
                                      
                   [*^#](x1, x2) = [0]
                                      
               [#mult^#](x1, x2) = [0]
                                      
                   [+^#](x1, x2) = [0]
                                      
                [#add^#](x1, x2) = [0]
                                      
              [attach^#](x1, x2) = [1] x1 + [1]
                                               
            [attach#1^#](x1, x2) = [1] x1 + [0]
                                               
        [attach#2^#](x1, x2, x3) = [1] x3 + [1]
                                               
            [lineMult^#](x1, x2) = [0]
                                      
          [lineMult#1^#](x1, x2) = [0]
                                      
                [mult^#](x1, x2) = [0]
                                      
              [mult#1^#](x1, x2) = [0]
                                      
                [makeBase^#](x1) = [0]
                                      
              [makeBase#1^#](x1) = [0]
                                      
                  [mkBase^#](x1) = [0]
                                      
                [mkBase#1^#](x1) = [0]
                                      
          [matrixMult^#](x1, x2) = [1] x2 + [0]
                                               
         [matrixMult'^#](x1, x2) = [0]
                                      
            [transAcc^#](x1, x2) = [1] x1 + [0]
                                               
          [transAcc#1^#](x1, x2) = [1] x1 + [0]
                                               
       [matrixMult'#1^#](x1, x2) = [0]
                                      
     [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                 
      [matrixMultList^#](x1, x2) = [1] x2 + [1]
                                               
    [matrixMultList#1^#](x1, x2) = [1] x1 + [0]
                                               
       [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
               [transpose^#](x1) = [0]
                                      
         [transpose#1^#](x1, x2) = [0]
                                      
          [mult#2^#](x1, x2, x3) = [0]
                                      
                   [split^#](x1) = [0]
                                      
                 [split#1^#](x1) = [0]
                                      
             [split#2^#](x1, x2) = [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                      
             [transpose#2^#](x1) = [0]
                                      
         [transpose#3^#](x1, x2) = [0]
                                      
              [transpose'^#](x1) = [1] x1 + [1]
                                               
            [#natmult^#](x1, x2) = [0]
                                      
                   [#pred^#](x1) = [0]
                                      
                   [#succ^#](x1) = [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                      
                       [c_1](x1) = [1] x1 + [0]
                                               
                       [c_2](x1) = [1] x1 + [0]
                                               
                       [c_3](x1) = [1] x1 + [0]
                                               
                       [c_4](x1) = [1] x1 + [0]
                                               
                   [c_5](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                       [c_6](x1) = [1] x1 + [0]
                                               
                       [c_7](x1) = [1] x1 + [0]
                                               
                       [c_8](x1) = [1] x1 + [0]
                                               
                       [c_9](x1) = [1] x1 + [0]
                                               
                      [c_10](x1) = [1] x1 + [0]
                                               
                      [c_11](x1) = [1] x1 + [0]
                                               
              [c_12](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
                                                                 
                      [c_13](x1) = [1] x1 + [0]
                                               
                      [c_14](x1) = [1] x1 + [0]
                                               
                  [c_15](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_16](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_17](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
                      [c_18](x1) = [1] x1 + [0]
                                               
                  [c_19](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_20](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_21](x1) = [1] x1 + [0]
                                               
                  [c_22](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_23](x1) = [1] x1 + [0]
                                               
                      [c_24](x1) = [1] x1 + [0]
                                               
                      [c_25](x1) = [1] x1 + [0]
                                               
                      [c_26](x1) = [1] x1 + [0]
                                               
                      [c_27](x1) = [1] x1 + [0]
                                               
                      [c_28](x1) = [1] x1 + [0]
                                               
                  [c_29](x1, x2) = [1] x1 + [1] x2 + [0]
  
  This order satisfies following ordering constraints
  
                      [attach^#(@line, @m)] =  [1] @line + [1]                                                   
                                            >  [1] @line + [0]                                                   
                                            =  [c_1(attach#1^#(@line, @m))]                                      
                                                                                                                 
              [attach#1^#(::(@x, @xs), @m)] =  [1] @x + [1] @xs + [1]                                            
                                            >= [1] @xs + [1]                                                     
                                            =  [c_2(attach#2^#(@m, @x, @xs))]                                    
                                                                                                                 
         [attach#2^#(::(@l, @ls), @x, @xs)] =  [1] @xs + [1]                                                     
                                            >= [1] @xs + [1]                                                     
                                            =  [c_3(attach^#(@xs, @ls))]                                         
                                                                                                                 
                      [lineMult^#(@l, @m2)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_4(lineMult#1^#(@m2, @l))]                                      
                                                                                                                 
            [lineMult#1^#(::(@x, @xs), @l)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_5(mult^#(@l, @x), lineMult^#(@l, @xs))]                        
                                                                                                                 
                         [mult^#(@l1, @l2)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_6(mult#1^#(@l1, @l2))]                                         
                                                                                                                 
               [mult#1^#(::(@x, @xs), @l2)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_7(mult#2^#(@l2, @x, @xs))]                                     
                                                                                                                 
                           [makeBase^#(@m)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_8(makeBase#1^#(@m))]                                           
                                                                                                                 
                [makeBase#1^#(::(@l, @m'))] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_9(mkBase^#(@l))]                                               
                                                                                                                 
                             [mkBase^#(@m)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_10(mkBase#1^#(@m))]                                            
                                                                                                                 
                  [mkBase#1^#(::(@l, @m'))] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_11(mkBase^#(@m'))]                                             
                                                                                                                 
                   [matrixMult^#(@m1, @m2)] =  [1] @m2 + [0]                                                     
                                            >= [1] @m2 + [0]                                                     
                                            =  [c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),           
                                                     transAcc^#(@m2, makeBase(@m2)),                             
                                                     makeBase^#(@m2))]                                           
                                                                                                                 
                  [matrixMult'^#(@m1, @m2)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_13(matrixMult'#1^#(@m1, @m2))]                                 
                                                                                                                 
                    [transAcc^#(@m, @base)] =  [1] @m + [0]                                                      
                                            >= [1] @m + [0]                                                      
                                            =  [c_14(transAcc#1^#(@m, @base))]                                   
                                                                                                                 
         [transAcc#1^#(::(@l, @m'), @base)] =  [1] @l + [1] @m' + [1]                                            
                                            >= [1] @l + [1] @m' + [1]                                            
                                            =  [c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))]
                                                                                                                 
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))]              
                                                                                                                 
             [matrixMult3^#(@m1, @m2, @m3)] =  [1] @m1 + [1] @m2 + [1] @m3 + [1]                                 
                                            >= [1] @m2 + [1] @m3 + [1]                                           
                                            =  [c_17(matrixMult^#(matrixMult(@m1, @m2), @m3),                    
                                                     matrixMult^#(@m1, @m2))]                                    
                                                                                                                 
              [matrixMultList^#(@acc, @mm)] =  [1] @mm + [1]                                                     
                                            >  [1] @mm + [0]                                                     
                                            =  [c_18(matrixMultList#1^#(@mm, @acc))]                             
                                                                                                                 
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1] @m + [1] @ms + [1]                                            
                                            >= [1] @m + [1] @ms + [1]                                            
                                            =  [c_19(matrixMultList^#(matrixMult(@acc, @m), @ms),                
                                                     matrixMult^#(@acc, @m))]                                    
                                                                                                                 
                [matrixMultOld^#(@m1, @m2)] =  [1] @m1 + [1] @m2 + [1]                                           
                                            >  [0]                                                               
                                            =  [c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))]      
                                                                                                                 
                          [transpose^#(@m)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_21(transpose#1^#(@m, @m))]                                     
                                                                                                                 
         [transpose#1^#(::(@xs, @xss), @m)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_22(transpose#2^#(split(@m)), split^#(@m))]                     
                                                                                                                 
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_23(mult^#(@xs, @ys))]                                          
                                                                                                                 
                              [split^#(@m)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_24(split#1^#(@m))]                                             
                                                                                                                 
                   [split#1^#(::(@l, @ls))] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_25(split#2^#(@l, @ls))]                                        
                                                                                                                 
              [split#2^#(::(@x, @xs), @ls)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_26(split^#(@ls))]                                              
                                                                                                                 
          [transpose#2^#(tuple#2(@l, @m'))] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_27(transpose#3^#(@m', @l))]                                    
                                                                                                                 
           [transpose#3^#(::(@y, @ys), @l)] =  [0]                                                               
                                            >= [0]                                                               
                                            =  [c_28(transpose^#(::(@y, @ys)))]                                  
                                                                                                                 
                         [transpose'^#(@m)] =  [1] @m + [1]                                                      
                                            >  [1] @m + [0]                                                      
                                            =  [c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))]              
                                                                                                                 

Consider the set of all dependency pairs

DPs:
  { 1: attach^#(@line, @m) -> c_1(attach#1^#(@line, @m))
  , 2: attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs))
  , 3: attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls))
  , 4: lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l))
  , 5: lineMult#1^#(::(@x, @xs), @l) ->
       c_5(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 6: mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2))
  , 7: mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs))
  , 8: makeBase^#(@m) -> c_8(makeBase#1^#(@m))
  , 9: makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l))
  , 10: mkBase^#(@m) -> c_10(mkBase#1^#(@m))
  , 11: mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m'))
  , 12: matrixMult^#(@m1, @m2) ->
        c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
             transAcc^#(@m2, makeBase(@m2)),
             makeBase^#(@m2))
  , 13: matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2))
  , 14: transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base))
  , 15: transAcc#1^#(::(@l, @m'), @base) ->
        c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , 16: matrixMult'#1^#(::(@l, @ls), @m2) ->
        c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , 17: matrixMult3^#(@m1, @m2, @m3) ->
        c_17(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 18: matrixMultList^#(@acc, @mm) ->
        c_18(matrixMultList#1^#(@mm, @acc))
  , 19: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_19(matrixMultList^#(matrixMult(@acc, @m), @ms),
             matrixMult^#(@acc, @m))
  , 20: matrixMultOld^#(@m1, @m2) ->
        c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , 21: transpose^#(@m) -> c_21(transpose#1^#(@m, @m))
  , 22: transpose#1^#(::(@xs, @xss), @m) ->
        c_22(transpose#2^#(split(@m)), split^#(@m))
  , 23: mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys))
  , 24: split^#(@m) -> c_24(split#1^#(@m))
  , 25: split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls))
  , 26: split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls))
  , 27: transpose#2^#(tuple#2(@l, @m')) ->
        c_27(transpose#3^#(@m', @l))
  , 28: transpose#3^#(::(@y, @ys), @l) ->
        c_28(transpose^#(::(@y, @ys)))
  , 29: transpose'^#(@m) ->
        c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }

Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {1,18,20,29}. These cover all (indirect) predecessors of
dependency pairs {1,2,3,8,9,12,17,18,19,20,29}, their number of
application is equally bounded. The dependency pairs are shifted
into the corresponding weak component(s).

We apply the transformation 'removetails' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_5(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs))
  , mkBase^#(@m) -> c_10(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m'))
  , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_21(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_22(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys))
  , split^#(@m) -> c_24(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_28(transpose^#(::(@y, @ys))) }
Weak DPs:
  { attach^#(@line, @m) -> c_1(attach#1^#(@line, @m))
  , attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs))
  , attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls))
  , makeBase^#(@m) -> c_8(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l))
  , matrixMult^#(@m1, @m2) ->
    c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_17(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_18(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_19(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) ->
    c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ attach^#(@line, @m) -> c_1(attach#1^#(@line, @m))
, attach#1^#(::(@x, @xs), @m) -> c_2(attach#2^#(@m, @x, @xs))
, attach#2^#(::(@l, @ls), @x, @xs) -> c_3(attach^#(@xs, @ls)) }

We apply the transformation 'simpDPRHS' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_4(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_5(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_6(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_7(mult#2^#(@l2, @x, @xs))
  , mkBase^#(@m) -> c_10(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_11(mkBase^#(@m'))
  , matrixMult'^#(@m1, @m2) -> c_13(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_14(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) ->
    c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_16(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_21(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_22(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_23(mult^#(@xs, @ys))
  , split^#(@m) -> c_24(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_25(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_26(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_27(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_28(transpose^#(::(@y, @ys))) }
Weak DPs:
  { makeBase^#(@m) -> c_8(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_9(mkBase^#(@l))
  , matrixMult^#(@m1, @m2) ->
    c_12(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_17(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_18(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_19(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_20(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) ->
    c_29(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { transAcc#1^#(::(@l, @m'), @base) ->
    c_15(attach^#(@l, transAcc(@m', @base)), transAcc^#(@m', @base)) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , mkBase^#(@m) -> c_5(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m'))
  , matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_11(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_12(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys))
  , split^#(@m) -> c_14(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_18(transpose^#(::(@y, @ys))) }
Weak DPs:
  { makeBase^#(@m) -> c_19(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l))
  , matrixMult^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_22(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_23(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_24(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) ->
    c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.

DPs:
  { 6: mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m'))
  , 20: makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l))
  , 22: matrixMult3^#(@m1, @m2, @m3) ->
        c_22(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2)) }
Trs:
  { attach#1(nil(), @m) -> nil()
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
    Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1},
    Uargs(c_10) = {1, 2}, Uargs(c_11) = {1}, Uargs(c_12) = {1, 2},
    Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1},
    Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1},
    Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1, 2, 3},
    Uargs(c_22) = {1, 2}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2},
    Uargs(c_25) = {1, 2}, Uargs(c_26) = {1, 2}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA).
  
                            [#0] = [0]
                                      
                      [#abs](x1) = [0]
                                      
                      [#neg](x1) = [0]
                                      
                      [#pos](x1) = [1] x1 + [0]
                                               
                        [#s](x1) = [0]
                                      
                     [*](x1, x2) = [0]
                                      
                 [#mult](x1, x2) = [1] x2 + [0]
                                               
                     [+](x1, x2) = [1] x1 + [0]
                                               
                  [#add](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                [attach](x1, x2) = [0]
                                      
              [attach#1](x1, x2) = [1] x1 + [1]
                                               
                    [::](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
          [attach#2](x1, x2, x3) = [1] x1 + [0]
                                               
                           [nil] = [0]
                                      
              [lineMult](x1, x2) = [1] x2 + [0]
                                               
            [lineMult#1](x1, x2) = [0]
                                      
                  [mult](x1, x2) = [0]
                                      
                  [makeBase](x1) = [1] x1 + [0]
                                               
                [makeBase#1](x1) = [1] x1 + [1]
                                               
                    [mkBase](x1) = [0]
                                      
            [matrixMult](x1, x2) = [1] x2 + [0]
                                               
              [transAcc](x1, x2) = [1] x2 + [1]
                                               
           [matrixMult'](x1, x2) = [0]
                                      
         [matrixMult'#1](x1, x2) = [0]
                                      
                 [transpose](x1) = [0]
                                      
                  [mkBase#1](x1) = [1]
                                      
                [mult#1](x1, x2) = [1]
                                      
            [mult#2](x1, x2, x3) = [0]
                                      
                     [split](x1) = [0]
                                      
                   [split#1](x1) = [1] x1 + [0]
                                               
               [split#2](x1, x2) = [0]
                                      
               [tuple#2](x1, x2) = [1]
                                      
           [split#3](x1, x2, x3) = [0]
                                      
            [transAcc#1](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
           [transpose#1](x1, x2) = [1]
                                      
               [transpose#2](x1) = [0]
                                      
           [transpose#3](x1, x2) = [0]
                                      
                     [#pred](x1) = [0]
                                      
                     [#succ](x1) = [0]
                                      
              [#natmult](x1, x2) = [0]
                                      
               [#natadd](x1, x2) = [0]
                                      
                    [#abs^#](x1) = [0]
                                      
                   [*^#](x1, x2) = [0]
                                      
               [#mult^#](x1, x2) = [0]
                                      
                   [+^#](x1, x2) = [0]
                                      
                [#add^#](x1, x2) = [0]
                                      
              [attach^#](x1, x2) = [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                      
            [lineMult^#](x1, x2) = [0]
                                      
          [lineMult#1^#](x1, x2) = [0]
                                      
                [mult^#](x1, x2) = [0]
                                      
              [mult#1^#](x1, x2) = [0]
                                      
                [makeBase^#](x1) = [1] x1 + [0]
                                               
              [makeBase#1^#](x1) = [1] x1 + [0]
                                               
                  [mkBase^#](x1) = [1] x1 + [0]
                                               
                [mkBase#1^#](x1) = [1] x1 + [0]
                                               
          [matrixMult^#](x1, x2) = [1] x2 + [0]
                                               
         [matrixMult'^#](x1, x2) = [0]
                                      
            [transAcc^#](x1, x2) = [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                      
       [matrixMult'#1^#](x1, x2) = [0]
                                      
     [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                 
      [matrixMultList^#](x1, x2) = [1] x2 + [1]
                                               
    [matrixMultList#1^#](x1, x2) = [1] x1 + [0]
                                               
       [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
               [transpose^#](x1) = [1]
                                      
         [transpose#1^#](x1, x2) = [1]
                                      
          [mult#2^#](x1, x2, x3) = [0]
                                      
                   [split^#](x1) = [0]
                                      
                 [split#1^#](x1) = [0]
                                      
             [split#2^#](x1, x2) = [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                      
             [transpose#2^#](x1) = [1]
                                      
         [transpose#3^#](x1, x2) = [1]
                                      
              [transpose'^#](x1) = [1] x1 + [1]
                                               
            [#natmult^#](x1, x2) = [0]
                                      
                   [#pred^#](x1) = [0]
                                      
                   [#succ^#](x1) = [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                      
                       [c_1](x1) = [0]
                                      
                       [c_2](x1) = [0]
                                      
                       [c_3](x1) = [0]
                                      
                       [c_4](x1) = [0]
                                      
                   [c_5](x1, x2) = [0]
                                      
                       [c_6](x1) = [0]
                                      
                       [c_7](x1) = [0]
                                      
                       [c_8](x1) = [0]
                                      
                       [c_9](x1) = [0]
                                      
                      [c_10](x1) = [0]
                                      
                      [c_11](x1) = [0]
                                      
              [c_12](x1, x2, x3) = [0]
                                      
                      [c_13](x1) = [0]
                                      
                      [c_14](x1) = [0]
                                      
                  [c_15](x1, x2) = [0]
                                      
                  [c_16](x1, x2) = [0]
                                      
                  [c_17](x1, x2) = [0]
                                      
                      [c_18](x1) = [0]
                                      
                  [c_19](x1, x2) = [0]
                                      
                  [c_20](x1, x2) = [0]
                                      
                      [c_21](x1) = [0]
                                      
                  [c_22](x1, x2) = [0]
                                      
                      [c_23](x1) = [0]
                                      
                      [c_24](x1) = [0]
                                      
                      [c_25](x1) = [0]
                                      
                      [c_26](x1) = [0]
                                      
                      [c_27](x1) = [0]
                                      
                      [c_28](x1) = [0]
                                      
                  [c_29](x1, x2) = [0]
                                      
                             [c] = [0]
                                      
                       [c_1](x1) = [1] x1 + [0]
                                               
                   [c_2](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                       [c_3](x1) = [1] x1 + [0]
                                               
                       [c_4](x1) = [1] x1 + [0]
                                               
                       [c_5](x1) = [1] x1 + [0]
                                               
                       [c_6](x1) = [1] x1 + [0]
                                               
                       [c_7](x1) = [1] x1 + [0]
                                               
                       [c_8](x1) = [1] x1 + [0]
                                               
                       [c_9](x1) = [1] x1 + [0]
                                               
                  [c_10](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_11](x1) = [1] x1 + [0]
                                               
                  [c_12](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_13](x1) = [1] x1 + [0]
                                               
                      [c_14](x1) = [1] x1 + [0]
                                               
                      [c_15](x1) = [1] x1 + [0]
                                               
                      [c_16](x1) = [1] x1 + [0]
                                               
                      [c_17](x1) = [1] x1 + [0]
                                               
                      [c_18](x1) = [1] x1 + [0]
                                               
                      [c_19](x1) = [1] x1 + [0]
                                               
                      [c_20](x1) = [1] x1 + [0]
                                               
              [c_21](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
                                                                 
                  [c_22](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_23](x1) = [1] x1 + [1]
                                               
                  [c_24](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_25](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_26](x1, x2) = [1] x1 + [1] x2 + [1]
  
  This order satisfies following ordering constraints
  
                      [lineMult^#(@l, @m2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_1(lineMult#1^#(@m2, @l))]                                
                                                                                                           
            [lineMult#1^#(::(@x, @xs), @l)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))]                  
                                                                                                           
                         [mult^#(@l1, @l2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_3(mult#1^#(@l1, @l2))]                                   
                                                                                                           
               [mult#1^#(::(@x, @xs), @l2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_4(mult#2^#(@l2, @x, @xs))]                               
                                                                                                           
                           [makeBase^#(@m)] =  [1] @m + [0]                                                
                                            >= [1] @m + [0]                                                
                                            =  [c_19(makeBase#1^#(@m))]                                    
                                                                                                           
                [makeBase#1^#(::(@l, @m'))] =  [1] @l + [1] @m' + [1]                                      
                                            >  [1] @l + [0]                                                
                                            =  [c_20(mkBase^#(@l))]                                        
                                                                                                           
                             [mkBase^#(@m)] =  [1] @m + [0]                                                
                                            >= [1] @m + [0]                                                
                                            =  [c_5(mkBase#1^#(@m))]                                       
                                                                                                           
                  [mkBase#1^#(::(@l, @m'))] =  [1] @l + [1] @m' + [1]                                      
                                            >  [1] @m' + [0]                                               
                                            =  [c_6(mkBase^#(@m'))]                                        
                                                                                                           
                   [matrixMult^#(@m1, @m2)] =  [1] @m2 + [0]                                               
                                            >= [1] @m2 + [0]                                               
                                            =  [c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),     
                                                     transAcc^#(@m2, makeBase(@m2)),                       
                                                     makeBase^#(@m2))]                                     
                                                                                                           
                  [matrixMult'^#(@m1, @m2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_7(matrixMult'#1^#(@m1, @m2))]                            
                                                                                                           
                    [transAcc^#(@m, @base)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_8(transAcc#1^#(@m, @base))]                              
                                                                                                           
         [transAcc#1^#(::(@l, @m'), @base)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_9(transAcc^#(@m', @base))]                               
                                                                                                           
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))]        
                                                                                                           
             [matrixMult3^#(@m1, @m2, @m3)] =  [1] @m1 + [1] @m2 + [1] @m3 + [1]                           
                                            >  [1] @m2 + [1] @m3 + [0]                                     
                                            =  [c_22(matrixMult^#(matrixMult(@m1, @m2), @m3),              
                                                     matrixMult^#(@m1, @m2))]                              
                                                                                                           
              [matrixMultList^#(@acc, @mm)] =  [1] @mm + [1]                                               
                                            >= [1] @mm + [1]                                               
                                            =  [c_23(matrixMultList#1^#(@mm, @acc))]                       
                                                                                                           
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1] @m + [1] @ms + [1]                                      
                                            >= [1] @m + [1] @ms + [1]                                      
                                            =  [c_24(matrixMultList^#(matrixMult(@acc, @m), @ms),          
                                                     matrixMult^#(@acc, @m))]                              
                                                                                                           
                [matrixMultOld^#(@m1, @m2)] =  [1] @m1 + [1] @m2 + [1]                                     
                                            >= [1]                                                         
                                            =  [c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))]
                                                                                                           
                          [transpose^#(@m)] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_11(transpose#1^#(@m, @m))]                               
                                                                                                           
         [transpose#1^#(::(@xs, @xss), @m)] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_12(transpose#2^#(split(@m)), split^#(@m))]               
                                                                                                           
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_13(mult^#(@xs, @ys))]                                    
                                                                                                           
                              [split^#(@m)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_14(split#1^#(@m))]                                       
                                                                                                           
                   [split#1^#(::(@l, @ls))] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_15(split#2^#(@l, @ls))]                                  
                                                                                                           
              [split#2^#(::(@x, @xs), @ls)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_16(split^#(@ls))]                                        
                                                                                                           
          [transpose#2^#(tuple#2(@l, @m'))] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_17(transpose#3^#(@m', @l))]                              
                                                                                                           
           [transpose#3^#(::(@y, @ys), @l)] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_18(transpose^#(::(@y, @ys)))]                            
                                                                                                           
                         [transpose'^#(@m)] =  [1] @m + [1]                                                
                                            >= [1] @m + [1]                                                
                                            =  [c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m))]        
                                                                                                           

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) ->
       c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , 5: mkBase^#(@m) -> c_5(mkBase#1^#(@m))
  , 6: mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m'))
  , 7: matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2))
  , 8: transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base))
  , 9: transAcc#1^#(::(@l, @m'), @base) ->
       c_9(transAcc^#(@m', @base))
  , 10: matrixMult'#1^#(::(@l, @ls), @m2) ->
        c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , 11: transpose^#(@m) -> c_11(transpose#1^#(@m, @m))
  , 12: transpose#1^#(::(@xs, @xss), @m) ->
        c_12(transpose#2^#(split(@m)), split^#(@m))
  , 13: mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys))
  , 14: split^#(@m) -> c_14(split#1^#(@m))
  , 15: split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls))
  , 16: split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls))
  , 17: transpose#2^#(tuple#2(@l, @m')) ->
        c_17(transpose#3^#(@m', @l))
  , 18: transpose#3^#(::(@y, @ys), @l) ->
        c_18(transpose^#(::(@y, @ys)))
  , 19: makeBase^#(@m) -> c_19(makeBase#1^#(@m))
  , 20: makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l))
  , 21: matrixMult^#(@m1, @m2) ->
        c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
             transAcc^#(@m2, makeBase(@m2)),
             makeBase^#(@m2))
  , 22: matrixMult3^#(@m1, @m2, @m3) ->
        c_22(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 23: matrixMultList^#(@acc, @mm) ->
        c_23(matrixMultList#1^#(@mm, @acc))
  , 24: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_24(matrixMultList^#(matrixMult(@acc, @m), @ms),
             matrixMult^#(@acc, @m))
  , 25: matrixMultOld^#(@m1, @m2) ->
        c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , 26: transpose'^#(@m) ->
        c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }

Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {6,20,22}. These cover all (indirect) predecessors of
dependency pairs {5,6,20,22,25,26}, their number of application is
equally bounded. The dependency pairs are shifted into the
corresponding weak component(s).

We apply the transformation 'removetails' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_11(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_12(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys))
  , split^#(@m) -> c_14(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_18(transpose^#(::(@y, @ys))) }
Weak DPs:
  { makeBase^#(@m) -> c_19(makeBase#1^#(@m))
  , makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l))
  , mkBase^#(@m) -> c_5(mkBase#1^#(@m))
  , mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m'))
  , matrixMult^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_22(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_23(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_24(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) ->
    c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ makeBase^#(@m) -> c_19(makeBase#1^#(@m))
, makeBase#1^#(::(@l, @m')) -> c_20(mkBase^#(@l))
, mkBase^#(@m) -> c_5(mkBase#1^#(@m))
, mkBase#1^#(::(@l, @m')) -> c_6(mkBase^#(@m')) }

We apply the transformation 'simpDPRHS' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_7(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_8(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) -> c_9(transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_10(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_11(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_12(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_13(mult^#(@xs, @ys))
  , split^#(@m) -> c_14(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_15(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_16(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_17(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_18(transpose^#(::(@y, @ys))) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_22(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_23(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_24(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_25(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) ->
    c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { matrixMult^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)),
         makeBase^#(@m2))
  , transpose'^#(@m) ->
    c_26(transAcc^#(@m, makeBase(@m)), makeBase^#(@m)) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_9(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_10(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys))
  , split^#(@m) -> c_12(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_16(transpose^#(::(@y, @ys))) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_18(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_19(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_20(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.

DPs:
  { 7: transAcc#1^#(::(@l, @m'), @base) ->
       c_7(transAcc^#(@m', @base))
  , 18: matrixMult3^#(@m1, @m2, @m3) ->
        c_18(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 19: matrixMultList^#(@acc, @mm) ->
        c_19(matrixMultList#1^#(@mm, @acc))
  , 22: transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) }
Trs:
  { #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , attach#1(nil(), @m) -> nil()
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m)) }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
    Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
    Uargs(c_10) = {1, 2}, Uargs(c_11) = {1}, Uargs(c_12) = {1},
    Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1},
    Uargs(c_16) = {1}, Uargs(c_17) = {1, 2}, Uargs(c_18) = {1, 2},
    Uargs(c_19) = {1}, Uargs(c_20) = {1, 2}, Uargs(c_21) = {1, 2},
    Uargs(c_22) = {1}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA).
  
                            [#0] = [0]
                                      
                      [#abs](x1) = [0]
                                      
                      [#neg](x1) = [1]
                                      
                      [#pos](x1) = [0]
                                      
                        [#s](x1) = [1]
                                      
                     [*](x1, x2) = [0]
                                      
                 [#mult](x1, x2) = [0]
                                      
                     [+](x1, x2) = [1] x1 + [0]
                                               
                  [#add](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                [attach](x1, x2) = [0]
                                      
              [attach#1](x1, x2) = [1] x1 + [1]
                                               
                    [::](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
          [attach#2](x1, x2, x3) = [1] x1 + [0]
                                               
                           [nil] = [1]
                                      
              [lineMult](x1, x2) = [1] x2 + [0]
                                               
            [lineMult#1](x1, x2) = [0]
                                      
                  [mult](x1, x2) = [0]
                                      
                  [makeBase](x1) = [1]
                                      
                [makeBase#1](x1) = [1] x1 + [1]
                                               
                    [mkBase](x1) = [0]
                                      
            [matrixMult](x1, x2) = [0]
                                      
              [transAcc](x1, x2) = [1] x2 + [1]
                                               
           [matrixMult'](x1, x2) = [1]
                                      
         [matrixMult'#1](x1, x2) = [1] x1 + [0]
                                               
                 [transpose](x1) = [0]
                                      
                  [mkBase#1](x1) = [0]
                                      
                [mult#1](x1, x2) = [1]
                                      
            [mult#2](x1, x2, x3) = [0]
                                      
                     [split](x1) = [0]
                                      
                   [split#1](x1) = [0]
                                      
               [split#2](x1, x2) = [1] x1 + [1]
                                               
               [tuple#2](x1, x2) = [1]
                                      
           [split#3](x1, x2, x3) = [0]
                                      
            [transAcc#1](x1, x2) = [1] x2 + [1]
                                               
           [transpose#1](x1, x2) = [1]
                                      
               [transpose#2](x1) = [0]
                                      
           [transpose#3](x1, x2) = [0]
                                      
                     [#pred](x1) = [0]
                                      
                     [#succ](x1) = [0]
                                      
              [#natmult](x1, x2) = [0]
                                      
               [#natadd](x1, x2) = [0]
                                      
                    [#abs^#](x1) = [0]
                                      
                   [*^#](x1, x2) = [0]
                                      
               [#mult^#](x1, x2) = [0]
                                      
                   [+^#](x1, x2) = [0]
                                      
                [#add^#](x1, x2) = [0]
                                      
              [attach^#](x1, x2) = [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                      
            [lineMult^#](x1, x2) = [0]
                                      
          [lineMult#1^#](x1, x2) = [0]
                                      
                [mult^#](x1, x2) = [0]
                                      
              [mult#1^#](x1, x2) = [0]
                                      
                [makeBase^#](x1) = [0]
                                      
              [makeBase#1^#](x1) = [0]
                                      
                  [mkBase^#](x1) = [0]
                                      
                [mkBase#1^#](x1) = [0]
                                      
          [matrixMult^#](x1, x2) = [1] x2 + [0]
                                               
         [matrixMult'^#](x1, x2) = [0]
                                      
            [transAcc^#](x1, x2) = [1] x1 + [0]
                                               
          [transAcc#1^#](x1, x2) = [1] x1 + [0]
                                               
       [matrixMult'#1^#](x1, x2) = [0]
                                      
     [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                 
      [matrixMultList^#](x1, x2) = [1] x2 + [1]
                                               
    [matrixMultList#1^#](x1, x2) = [1] x1 + [0]
                                               
       [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1]
                                                        
               [transpose^#](x1) = [1]
                                      
         [transpose#1^#](x1, x2) = [1]
                                      
          [mult#2^#](x1, x2, x3) = [0]
                                      
                   [split^#](x1) = [0]
                                      
                 [split#1^#](x1) = [0]
                                      
             [split#2^#](x1, x2) = [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                      
             [transpose#2^#](x1) = [1]
                                      
         [transpose#3^#](x1, x2) = [1]
                                      
              [transpose'^#](x1) = [1] x1 + [1]
                                               
            [#natmult^#](x1, x2) = [0]
                                      
                   [#pred^#](x1) = [0]
                                      
                   [#succ^#](x1) = [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                      
                       [c_1](x1) = [0]
                                      
                       [c_2](x1) = [0]
                                      
                       [c_3](x1) = [0]
                                      
                       [c_4](x1) = [0]
                                      
                   [c_5](x1, x2) = [0]
                                      
                       [c_6](x1) = [0]
                                      
                       [c_7](x1) = [0]
                                      
                       [c_8](x1) = [0]
                                      
                       [c_9](x1) = [0]
                                      
                      [c_10](x1) = [0]
                                      
                      [c_11](x1) = [0]
                                      
              [c_12](x1, x2, x3) = [0]
                                      
                      [c_13](x1) = [0]
                                      
                      [c_14](x1) = [0]
                                      
                  [c_15](x1, x2) = [0]
                                      
                  [c_16](x1, x2) = [0]
                                      
                  [c_17](x1, x2) = [0]
                                      
                      [c_18](x1) = [0]
                                      
                  [c_19](x1, x2) = [0]
                                      
                  [c_20](x1, x2) = [0]
                                      
                      [c_21](x1) = [0]
                                      
                  [c_22](x1, x2) = [0]
                                      
                      [c_23](x1) = [0]
                                      
                      [c_24](x1) = [0]
                                      
                      [c_25](x1) = [0]
                                      
                      [c_26](x1) = [0]
                                      
                      [c_27](x1) = [0]
                                      
                      [c_28](x1) = [0]
                                      
                  [c_29](x1, x2) = [0]
                                      
                             [c] = [0]
                                      
                       [c_1](x1) = [0]
                                      
                   [c_2](x1, x2) = [0]
                                      
                       [c_3](x1) = [0]
                                      
                       [c_4](x1) = [0]
                                      
                       [c_5](x1) = [0]
                                      
                       [c_6](x1) = [0]
                                      
                       [c_7](x1) = [0]
                                      
                       [c_8](x1) = [0]
                                      
                       [c_9](x1) = [0]
                                      
                  [c_10](x1, x2) = [0]
                                      
                      [c_11](x1) = [0]
                                      
                  [c_12](x1, x2) = [0]
                                      
                      [c_13](x1) = [0]
                                      
                      [c_14](x1) = [0]
                                      
                      [c_15](x1) = [0]
                                      
                      [c_16](x1) = [0]
                                      
                      [c_17](x1) = [0]
                                      
                      [c_18](x1) = [0]
                                      
                      [c_19](x1) = [0]
                                      
                      [c_20](x1) = [0]
                                      
              [c_21](x1, x2, x3) = [0]
                                      
                  [c_22](x1, x2) = [0]
                                      
                      [c_23](x1) = [0]
                                      
                  [c_24](x1, x2) = [0]
                                      
                  [c_25](x1, x2) = [0]
                                      
                  [c_26](x1, x2) = [0]
                                      
                             [c] = [0]
                                      
                       [c_1](x1) = [1] x1 + [0]
                                               
                   [c_2](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                       [c_3](x1) = [1] x1 + [0]
                                               
                       [c_4](x1) = [1] x1 + [0]
                                               
                       [c_5](x1) = [1] x1 + [0]
                                               
                       [c_6](x1) = [1] x1 + [0]
                                               
                       [c_7](x1) = [1] x1 + [0]
                                               
                   [c_8](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                       [c_9](x1) = [1] x1 + [0]
                                               
                  [c_10](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_11](x1) = [1] x1 + [0]
                                               
                      [c_12](x1) = [1] x1 + [0]
                                               
                      [c_13](x1) = [1] x1 + [0]
                                               
                      [c_14](x1) = [1] x1 + [0]
                                               
                      [c_15](x1) = [1] x1 + [0]
                                               
                      [c_16](x1) = [1] x1 + [0]
                                               
                  [c_17](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_18](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_19](x1) = [1] x1 + [0]
                                               
                  [c_20](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                  [c_21](x1, x2) = [1] x1 + [1] x2 + [0]
                                                        
                      [c_22](x1) = [1] x1 + [0]
  
  This order satisfies following ordering constraints
  
                      [lineMult^#(@l, @m2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_1(lineMult#1^#(@m2, @l))]                                
                                                                                                           
            [lineMult#1^#(::(@x, @xs), @l)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))]                  
                                                                                                           
                         [mult^#(@l1, @l2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_3(mult#1^#(@l1, @l2))]                                   
                                                                                                           
               [mult#1^#(::(@x, @xs), @l2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_4(mult#2^#(@l2, @x, @xs))]                               
                                                                                                           
                   [matrixMult^#(@m1, @m2)] =  [1] @m2 + [0]                                               
                                            >= [1] @m2 + [0]                                               
                                            =  [c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),     
                                                     transAcc^#(@m2, makeBase(@m2)))]                      
                                                                                                           
                  [matrixMult'^#(@m1, @m2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_5(matrixMult'#1^#(@m1, @m2))]                            
                                                                                                           
                    [transAcc^#(@m, @base)] =  [1] @m + [0]                                                
                                            >= [1] @m + [0]                                                
                                            =  [c_6(transAcc#1^#(@m, @base))]                              
                                                                                                           
         [transAcc#1^#(::(@l, @m'), @base)] =  [1] @l + [1] @m' + [1]                                      
                                            >  [1] @m' + [0]                                               
                                            =  [c_7(transAcc^#(@m', @base))]                               
                                                                                                           
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))]         
                                                                                                           
             [matrixMult3^#(@m1, @m2, @m3)] =  [1] @m1 + [1] @m2 + [1] @m3 + [1]                           
                                            >  [1] @m2 + [1] @m3 + [0]                                     
                                            =  [c_18(matrixMult^#(matrixMult(@m1, @m2), @m3),              
                                                     matrixMult^#(@m1, @m2))]                              
                                                                                                           
              [matrixMultList^#(@acc, @mm)] =  [1] @mm + [1]                                               
                                            >  [1] @mm + [0]                                               
                                            =  [c_19(matrixMultList#1^#(@mm, @acc))]                       
                                                                                                           
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1] @m + [1] @ms + [1]                                      
                                            >= [1] @m + [1] @ms + [1]                                      
                                            =  [c_20(matrixMultList^#(matrixMult(@acc, @m), @ms),          
                                                     matrixMult^#(@acc, @m))]                              
                                                                                                           
                [matrixMultOld^#(@m1, @m2)] =  [1] @m1 + [1] @m2 + [1]                                     
                                            >= [1]                                                         
                                            =  [c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))]
                                                                                                           
                          [transpose^#(@m)] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_9(transpose#1^#(@m, @m))]                                
                                                                                                           
         [transpose#1^#(::(@xs, @xss), @m)] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_10(transpose#2^#(split(@m)), split^#(@m))]               
                                                                                                           
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_11(mult^#(@xs, @ys))]                                    
                                                                                                           
                              [split^#(@m)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_12(split#1^#(@m))]                                       
                                                                                                           
                   [split#1^#(::(@l, @ls))] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_13(split#2^#(@l, @ls))]                                  
                                                                                                           
              [split#2^#(::(@x, @xs), @ls)] =  [0]                                                         
                                            >= [0]                                                         
                                            =  [c_14(split^#(@ls))]                                        
                                                                                                           
          [transpose#2^#(tuple#2(@l, @m'))] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_15(transpose#3^#(@m', @l))]                              
                                                                                                           
           [transpose#3^#(::(@y, @ys), @l)] =  [1]                                                         
                                            >= [1]                                                         
                                            =  [c_16(transpose^#(::(@y, @ys)))]                            
                                                                                                           
                         [transpose'^#(@m)] =  [1] @m + [1]                                                
                                            >  [1] @m + [0]                                                
                                            =  [c_22(transAcc^#(@m, makeBase(@m)))]                        
                                                                                                           

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) ->
       c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , 6: transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base))
  , 7: transAcc#1^#(::(@l, @m'), @base) ->
       c_7(transAcc^#(@m', @base))
  , 8: matrixMult'#1^#(::(@l, @ls), @m2) ->
       c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , 9: transpose^#(@m) -> c_9(transpose#1^#(@m, @m))
  , 10: transpose#1^#(::(@xs, @xss), @m) ->
        c_10(transpose#2^#(split(@m)), split^#(@m))
  , 11: mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys))
  , 12: split^#(@m) -> c_12(split#1^#(@m))
  , 13: split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls))
  , 14: split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls))
  , 15: transpose#2^#(tuple#2(@l, @m')) ->
        c_15(transpose#3^#(@m', @l))
  , 16: transpose#3^#(::(@y, @ys), @l) ->
        c_16(transpose^#(::(@y, @ys)))
  , 17: matrixMult^#(@m1, @m2) ->
        c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
             transAcc^#(@m2, makeBase(@m2)))
  , 18: matrixMult3^#(@m1, @m2, @m3) ->
        c_18(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 19: matrixMultList^#(@acc, @mm) ->
        c_19(matrixMultList#1^#(@mm, @acc))
  , 20: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_20(matrixMultList^#(matrixMult(@acc, @m), @ms),
             matrixMult^#(@acc, @m))
  , 21: matrixMultOld^#(@m1, @m2) ->
        c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , 22: transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) }

Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {7,18,19,22}. These cover all (indirect) predecessors of
dependency pairs {6,7,17,18,19,20,21,22}, their number of
application is equally bounded. The dependency pairs are shifted
into the corresponding weak component(s).

We apply the transformation 'removetails' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_9(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_10(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys))
  , split^#(@m) -> c_12(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_16(transpose^#(::(@y, @ys))) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)))
  , transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base))
  , transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_18(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_19(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_20(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ transAcc^#(@m, @base) -> c_6(transAcc#1^#(@m, @base))
, transAcc#1^#(::(@l, @m'), @base) -> c_7(transAcc^#(@m', @base))
, transpose'^#(@m) -> c_22(transAcc^#(@m, makeBase(@m))) }

We apply the transformation 'simpDPRHS' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_8(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_9(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_10(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_11(mult^#(@xs, @ys))
  , split^#(@m) -> c_12(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_13(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_14(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_15(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_16(transpose^#(::(@y, @ys))) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2)))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_18(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_19(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_20(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_21(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { matrixMult^#(@m1, @m2) ->
    c_17(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))),
         transAcc^#(@m2, makeBase(@m2))) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_7(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_8(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys))
  , split^#(@m) -> c_10(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_14(transpose^#(::(@y, @ys))) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_17(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.

DPs:
  { 11: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) }
Trs:
  { attach#2(nil(), @x, @xs) -> nil()
  , makeBase#1(nil()) -> nil()
  , mkBase#1(nil()) -> nil()
  , split#1(nil()) -> tuple#2(nil(), nil())
  , transAcc#1(nil(), @base) -> @base }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1, 2},
    Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
    Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1},
    Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1},
    Uargs(c_16) = {1, 2}, Uargs(c_17) = {1}, Uargs(c_18) = {1, 2},
    Uargs(c_19) = {1, 2}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA) and not(IDA(1)).
  
                            [#0] = [0]
                                   [0]
                                      
                      [#abs](x1) = [0]
                                   [0]
                                      
                      [#neg](x1) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
                      [#pos](x1) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
                        [#s](x1) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
                     [*](x1, x2) = [0]
                                   [0]
                                      
                 [#mult](x1, x2) = [0]
                                   [0]
                                      
                     [+](x1, x2) = [1 0] x2 + [0]
                                   [0 1]      [0]
                                                 
                  [#add](x1, x2) = [1 0] x2 + [0]
                                   [1 1]      [0]
                                                 
                [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
              [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
                    [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
          [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1]
                                   [0 1]      [0 0]      [0 0]      [1]
                                                                       
                           [nil] = [1]
                                   [0]
                                      
              [lineMult](x1, x2) = [1]
                                   [0]
                                      
            [lineMult#1](x1, x2) = [1 0] x2 + [1]
                                   [1 0]      [1]
                                                 
                  [mult](x1, x2) = [0]
                                   [0]
                                      
                  [makeBase](x1) = [1 0] x1 + [1]
                                   [1 1]      [0]
                                                 
                [makeBase#1](x1) = [1 0] x1 + [1]
                                   [1 1]      [0]
                                                 
                    [mkBase](x1) = [1 1] x1 + [1]
                                   [0 1]      [1]
                                                 
            [matrixMult](x1, x2) = [1 0] x1 + [1]
                                   [1 1]      [1]
                                                 
              [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 1]      [1 1]      [0]
                                                            
           [matrixMult'](x1, x2) = [1 1] x1 + [0]
                                   [1 0]      [1]
                                                 
         [matrixMult'#1](x1, x2) = [1 1] x1 + [0]
                                   [1 1]      [1]
                                                 
                 [transpose](x1) = [1 0] x1 + [1]
                                   [1 0]      [0]
                                                 
                  [mkBase#1](x1) = [1 1] x1 + [1]
                                   [0 1]      [1]
                                                 
                [mult#1](x1, x2) = [0]
                                   [0]
                                      
            [mult#2](x1, x2, x3) = [0 0] x2 + [0]
                                   [1 1]      [0]
                                                 
                     [split](x1) = [1 0] x1 + [0]
                                   [1 0]      [1]
                                                 
                   [split#1](x1) = [1 0] x1 + [0]
                                   [1 0]      [1]
                                                 
               [split#2](x1, x2) = [0 1] x1 + [1 0] x2 + [0]
                                   [1 1]      [1 0]      [1]
                                                            
               [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0]
                                   [0 0]      [1 1]      [1]
                                                            
           [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [1]
                                   [0 1]      [1 1]      [1 1]      [1]
                                                                       
            [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 1]      [1 1]      [0]
                                                            
           [transpose#1](x1, x2) = [1]
                                   [0]
                                      
               [transpose#2](x1) = [1 0] x1 + [0]
                                   [1 0]      [0]
                                                 
           [transpose#3](x1, x2) = [0 0] x1 + [1 0] x2 + [0]
                                   [1 0]      [0 1]      [1]
                                                            
                     [#pred](x1) = [0]
                                   [0]
                                      
                     [#succ](x1) = [0]
                                   [0]
                                      
              [#natmult](x1, x2) = [0 0] x1 + [0]
                                   [1 0]      [0]
                                                 
               [#natadd](x1, x2) = [0]
                                   [0]
                                      
                    [#abs^#](x1) = [0]
                                   [0]
                                      
                   [*^#](x1, x2) = [0]
                                   [0]
                                      
               [#mult^#](x1, x2) = [0]
                                   [0]
                                      
                   [+^#](x1, x2) = [0]
                                   [0]
                                      
                [#add^#](x1, x2) = [0]
                                   [0]
                                      
              [attach^#](x1, x2) = [0]
                                   [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                   [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
            [lineMult^#](x1, x2) = [0]
                                   [0]
                                      
          [lineMult#1^#](x1, x2) = [0]
                                   [0]
                                      
                [mult^#](x1, x2) = [0]
                                   [0]
                                      
              [mult#1^#](x1, x2) = [0]
                                   [0]
                                      
                [makeBase^#](x1) = [0]
                                   [0]
                                      
              [makeBase#1^#](x1) = [0]
                                   [0]
                                      
                  [mkBase^#](x1) = [0]
                                   [0]
                                      
                [mkBase#1^#](x1) = [0]
                                   [0]
                                      
          [matrixMult^#](x1, x2) = [0]
                                   [0]
                                      
         [matrixMult'^#](x1, x2) = [0]
                                   [0]
                                      
            [transAcc^#](x1, x2) = [0]
                                   [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMult'#1^#](x1, x2) = [0]
                                   [0]
                                      
     [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 0] x3 + [1]
                                   [1 1]      [1 1]      [1 1]      [1]
                                                                       
      [matrixMultList^#](x1, x2) = [0]
                                   [0]
                                      
    [matrixMultList#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1]
                                   [1 1]      [1 1]      [1]
                                                            
               [transpose^#](x1) = [1 1] x1 + [1]
                                   [0 0]      [0]
                                                 
         [transpose#1^#](x1, x2) = [1 1] x2 + [1]
                                   [0 0]      [0]
                                                 
          [mult#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
                   [split^#](x1) = [0 1] x1 + [0]
                                   [1 0]      [0]
                                                 
                 [split#1^#](x1) = [0 1] x1 + [0]
                                   [0 0]      [0]
                                                 
             [split#2^#](x1, x2) = [0 1] x2 + [0]
                                   [0 0]      [0]
                                                 
         [split#3^#](x1, x2, x3) = [0]
                                   [0]
                                      
             [transpose#2^#](x1) = [0 1] x1 + [0]
                                   [1 1]      [0]
                                                 
         [transpose#3^#](x1, x2) = [1 1] x1 + [1]
                                   [0 0]      [0]
                                                 
              [transpose'^#](x1) = [0]
                                   [0]
                                      
            [#natmult^#](x1, x2) = [0]
                                   [0]
                                      
                   [#pred^#](x1) = [0]
                                   [0]
                                      
                   [#succ^#](x1) = [0]
                                   [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                       [c_2](x1) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                   [c_5](x1, x2) = [0]
                                   [0]
                                      
                       [c_6](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                       [c_8](x1) = [0]
                                   [0]
                                      
                       [c_9](x1) = [0]
                                   [0]
                                      
                      [c_10](x1) = [0]
                                   [0]
                                      
                      [c_11](x1) = [0]
                                   [0]
                                      
              [c_12](x1, x2, x3) = [0]
                                   [0]
                                      
                      [c_13](x1) = [0]
                                   [0]
                                      
                      [c_14](x1) = [0]
                                   [0]
                                      
                  [c_15](x1, x2) = [0]
                                   [0]
                                      
                  [c_16](x1, x2) = [0]
                                   [0]
                                      
                  [c_17](x1, x2) = [0]
                                   [0]
                                      
                      [c_18](x1) = [0]
                                   [0]
                                      
                  [c_19](x1, x2) = [0]
                                   [0]
                                      
                  [c_20](x1, x2) = [0]
                                   [0]
                                      
                      [c_21](x1) = [0]
                                   [0]
                                      
                  [c_22](x1, x2) = [0]
                                   [0]
                                      
                      [c_23](x1) = [0]
                                   [0]
                                      
                      [c_24](x1) = [0]
                                   [0]
                                      
                      [c_25](x1) = [0]
                                   [0]
                                      
                      [c_26](x1) = [0]
                                   [0]
                                      
                      [c_27](x1) = [0]
                                   [0]
                                      
                      [c_28](x1) = [0]
                                   [0]
                                      
                  [c_29](x1, x2) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                   [c_2](x1, x2) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                       [c_5](x1) = [0]
                                   [0]
                                      
                       [c_6](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                       [c_8](x1) = [0]
                                   [0]
                                      
                       [c_9](x1) = [0]
                                   [0]
                                      
                  [c_10](x1, x2) = [0]
                                   [0]
                                      
                      [c_11](x1) = [0]
                                   [0]
                                      
                  [c_12](x1, x2) = [0]
                                   [0]
                                      
                      [c_13](x1) = [0]
                                   [0]
                                      
                      [c_14](x1) = [0]
                                   [0]
                                      
                      [c_15](x1) = [0]
                                   [0]
                                      
                      [c_16](x1) = [0]
                                   [0]
                                      
                      [c_17](x1) = [0]
                                   [0]
                                      
                      [c_18](x1) = [0]
                                   [0]
                                      
                      [c_19](x1) = [0]
                                   [0]
                                      
                      [c_20](x1) = [0]
                                   [0]
                                      
              [c_21](x1, x2, x3) = [0]
                                   [0]
                                      
                  [c_22](x1, x2) = [0]
                                   [0]
                                      
                      [c_23](x1) = [0]
                                   [0]
                                      
                  [c_24](x1, x2) = [0]
                                   [0]
                                      
                  [c_25](x1, x2) = [0]
                                   [0]
                                      
                  [c_26](x1, x2) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                   [c_2](x1, x2) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                       [c_5](x1) = [0]
                                   [0]
                                      
                       [c_6](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                   [c_8](x1, x2) = [0]
                                   [0]
                                      
                       [c_9](x1) = [0]
                                   [0]
                                      
                  [c_10](x1, x2) = [0]
                                   [0]
                                      
                      [c_11](x1) = [0]
                                   [0]
                                      
                      [c_12](x1) = [0]
                                   [0]
                                      
                      [c_13](x1) = [0]
                                   [0]
                                      
                      [c_14](x1) = [0]
                                   [0]
                                      
                      [c_15](x1) = [0]
                                   [0]
                                      
                      [c_16](x1) = [0]
                                   [0]
                                      
                  [c_17](x1, x2) = [0]
                                   [0]
                                      
                  [c_18](x1, x2) = [0]
                                   [0]
                                      
                      [c_19](x1) = [0]
                                   [0]
                                      
                  [c_20](x1, x2) = [0]
                                   [0]
                                      
                  [c_21](x1, x2) = [0]
                                   [0]
                                      
                      [c_22](x1) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_2](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_3](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_4](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_5](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_6](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_7](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_8](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_9](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_10](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_11](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_12](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_13](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_14](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_15](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                  [c_16](x1, x2) = [1 0] x1 + [1 0] x2 + [1]
                                   [0 0]      [0 0]      [1]
                                                            
                      [c_17](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                  [c_18](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                  [c_19](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [1]
  
  This order satisfies following ordering constraints
  
                        [attach(@line, @m)] =  [1 1] @line + [1 0] @m + [0]                                
                                               [0 0]         [0 1]      [1]                                
                                            >= [1 1] @line + [1 0] @m + [0]                                
                                               [0 0]         [0 1]      [1]                                
                                            =  [attach#1(@line, @m)]                                       
                                                                                                           
                [attach#1(::(@x, @xs), @m)] =  [1 0] @m + [1 1] @x + [1 1] @xs + [1]                       
                                               [0 1]      [0 0]      [0 0]       [1]                       
                                            >= [1 0] @m + [1 1] @x + [1 1] @xs + [1]                       
                                               [0 1]      [0 0]      [0 0]       [1]                       
                                            =  [attach#2(@m, @x, @xs)]                                     
                                                                                                           
                      [attach#1(nil(), @m)] =  [1 0] @m + [1]                                              
                                               [0 1]      [1]                                              
                                            >= [1]                                                         
                                               [0]                                                         
                                            =  [nil()]                                                     
                                                                                                           
           [attach#2(::(@l, @ls), @x, @xs)] =  [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1]           
                                               [0 0]      [0 1]       [0 0]      [0 0]       [2]           
                                            >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1]           
                                               [0 0]      [0 1]       [0 0]      [0 0]       [2]           
                                            =  [::(::(@x, @l), attach(@xs, @ls))]                          
                                                                                                           
                 [attach#2(nil(), @x, @xs)] =  [1 1] @x + [1 1] @xs + [2]                                  
                                               [0 0]      [0 0]       [1]                                  
                                            >  [1]                                                         
                                               [0]                                                         
                                            =  [nil()]                                                     
                                                                                                           
                             [makeBase(@m)] =  [1 0] @m + [1]                                              
                                               [1 1]      [0]                                              
                                            >= [1 0] @m + [1]                                              
                                               [1 1]      [0]                                              
                                            =  [makeBase#1(@m)]                                            
                                                                                                           
                  [makeBase#1(::(@l, @m'))] =  [1 1] @l + [1 0] @m' + [1]                                  
                                               [1 1]      [1 1]       [1]                                  
                                            >= [1 1] @l + [1]                                              
                                               [0 1]      [1]                                              
                                            =  [mkBase(@l)]                                                
                                                                                                           
                        [makeBase#1(nil())] =  [2]                                                         
                                               [1]                                                         
                                            >  [1]                                                         
                                               [0]                                                         
                                            =  [nil()]                                                     
                                                                                                           
                               [mkBase(@m)] =  [1 1] @m + [1]                                              
                                               [0 1]      [1]                                              
                                            >= [1 1] @m + [1]                                              
                                               [0 1]      [1]                                              
                                            =  [mkBase#1(@m)]                                              
                                                                                                           
                      [transAcc(@m, @base)] =  [1 0] @base + [1 0] @m + [0]                                
                                               [1 1]         [0 1]      [0]                                
                                            >= [1 0] @base + [1 0] @m + [0]                                
                                               [1 1]         [0 1]      [0]                                
                                            =  [transAcc#1(@m, @base)]                                     
                                                                                                           
                    [mkBase#1(::(@l, @m'))] =  [1 1] @l + [1 1] @m' + [2]                                  
                                               [0 0]      [0 1]       [2]                                  
                                            >= [1 1] @m' + [2]                                             
                                               [0 1]       [2]                                             
                                            =  [::(nil(), mkBase(@m'))]                                    
                                                                                                           
                          [mkBase#1(nil())] =  [2]                                                         
                                               [1]                                                         
                                            >  [1]                                                         
                                               [0]                                                         
                                            =  [nil()]                                                     
                                                                                                           
                                [split(@m)] =  [1 0] @m + [0]                                              
                                               [1 0]      [1]                                              
                                            >= [1 0] @m + [0]                                              
                                               [1 0]      [1]                                              
                                            =  [split#1(@m)]                                               
                                                                                                           
                     [split#1(::(@l, @ls))] =  [1 1] @l + [1 0] @ls + [0]                                  
                                               [1 1]      [1 0]       [1]                                  
                                            >= [0 1] @l + [1 0] @ls + [0]                                  
                                               [1 1]      [1 0]       [1]                                  
                                            =  [split#2(@l, @ls)]                                          
                                                                                                           
                           [split#1(nil())] =  [1]                                                         
                                               [2]                                                         
                                            >  [0]                                                         
                                               [2]                                                         
                                            =  [tuple#2(nil(), nil())]                                     
                                                                                                           
                [split#2(::(@x, @xs), @ls)] =  [1 0] @ls + [0 0] @x + [0 1] @xs + [1]                      
                                               [1 0]       [1 1]      [1 1]       [2]                      
                                            >= [1 0] @ls + [0 0] @x + [0 0] @xs + [1]                      
                                               [1 0]       [1 1]      [1 1]       [2]                      
                                            =  [split#3(split(@ls), @x, @xs)]                              
                                                                                                           
                      [split#2(nil(), @ls)] =  [1 0] @ls + [0]                                             
                                               [1 0]       [2]                                             
                                            >= [0]                                                         
                                               [2]                                                         
                                            =  [tuple#2(nil(), nil())]                                     
                                                                                                           
      [split#3(tuple#2(@ys, @m'), @x, @xs)] =  [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1]          
                                               [1 1]       [1 1]      [1 1]       [0 0]       [2]          
                                            >= [0 0] @m' + [0 0] @xs + [0 1] @ys + [1]                     
                                               [1 1]       [1 1]       [0 0]       [2]                     
                                            =  [tuple#2(::(@x, @ys), ::(@xs, @m'))]                        
                                                                                                           
           [transAcc#1(::(@l, @m'), @base)] =  [1 0] @base + [1 1] @l + [1 0] @m' + [0]                    
                                               [1 1]         [0 0]      [0 1]       [1]                    
                                            >= [1 0] @base + [1 1] @l + [1 0] @m' + [0]                    
                                               [1 1]         [0 0]      [0 1]       [1]                    
                                            =  [attach(@l, transAcc(@m', @base))]                          
                                                                                                           
                 [transAcc#1(nil(), @base)] =  [1 0] @base + [1]                                           
                                               [1 1]         [0]                                           
                                            >  [1 0] @base + [0]                                           
                                               [0 1]         [0]                                           
                                            =  [@base]                                                     
                                                                                                           
                      [lineMult^#(@l, @m2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_1(lineMult#1^#(@m2, @l))]                                
                                                                                                           
            [lineMult#1^#(::(@x, @xs), @l)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))]                  
                                                                                                           
                         [mult^#(@l1, @l2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_3(mult#1^#(@l1, @l2))]                                   
                                                                                                           
               [mult#1^#(::(@x, @xs), @l2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_4(mult#2^#(@l2, @x, @xs))]                               
                                                                                                           
                   [matrixMult^#(@m1, @m2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))]    
                                                                                                           
                  [matrixMult'^#(@m1, @m2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_5(matrixMult'#1^#(@m1, @m2))]                            
                                                                                                           
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))]         
                                                                                                           
             [matrixMult3^#(@m1, @m2, @m3)] =  [1 0] @m1 + [1 0] @m2 + [1 0] @m3 + [1]                     
                                               [1 1]       [1 1]       [1 1]       [1]                     
                                            >= [1]                                                         
                                               [1]                                                         
                                            =  [c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),              
                                                     matrixMult^#(@m1, @m2))]                              
                                                                                                           
              [matrixMultList^#(@acc, @mm)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_17(matrixMultList#1^#(@mm, @acc))]                       
                                                                                                           
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),          
                                                     matrixMult^#(@acc, @m))]                              
                                                                                                           
                [matrixMultOld^#(@m1, @m2)] =  [1 0] @m1 + [1 1] @m2 + [1]                                 
                                               [1 1]       [1 1]       [1]                                 
                                            >= [1 1] @m2 + [1]                                             
                                               [0 0]       [1]                                             
                                            =  [c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))]
                                                                                                           
                          [transpose^#(@m)] =  [1 1] @m + [1]                                              
                                               [0 0]      [0]                                              
                                            >= [1 1] @m + [1]                                              
                                               [0 0]      [0]                                              
                                            =  [c_7(transpose#1^#(@m, @m))]                                
                                                                                                           
         [transpose#1^#(::(@xs, @xss), @m)] =  [1 1] @m + [1]                                              
                                               [0 0]      [0]                                              
                                            >= [1 1] @m + [1]                                              
                                               [0 0]      [0]                                              
                                            =  [c_8(transpose#2^#(split(@m)), split^#(@m))]                
                                                                                                           
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_9(mult^#(@xs, @ys))]                                     
                                                                                                           
                              [split^#(@m)] =  [0 1] @m + [0]                                              
                                               [1 0]      [0]                                              
                                            >= [0 1] @m + [0]                                              
                                               [0 0]      [0]                                              
                                            =  [c_10(split#1^#(@m))]                                       
                                                                                                           
                   [split#1^#(::(@l, @ls))] =  [0 1] @ls + [1]                                             
                                               [0 0]       [0]                                             
                                            >  [0 1] @ls + [0]                                             
                                               [0 0]       [0]                                             
                                            =  [c_11(split#2^#(@l, @ls))]                                  
                                                                                                           
              [split#2^#(::(@x, @xs), @ls)] =  [0 1] @ls + [0]                                             
                                               [0 0]       [0]                                             
                                            >= [0 1] @ls + [0]                                             
                                               [0 0]       [0]                                             
                                            =  [c_12(split^#(@ls))]                                        
                                                                                                           
          [transpose#2^#(tuple#2(@l, @m'))] =  [0 0] @l + [1 1] @m' + [1]                                  
                                               [0 1]      [1 1]       [1]                                  
                                            >= [1 1] @m' + [1]                                             
                                               [0 0]       [0]                                             
                                            =  [c_13(transpose#3^#(@m', @l))]                              
                                                                                                           
           [transpose#3^#(::(@y, @ys), @l)] =  [1 1] @y + [1 1] @ys + [2]                                  
                                               [0 0]      [0 0]       [0]                                  
                                            >= [1 1] @y + [1 1] @ys + [2]                                  
                                               [0 0]      [0 0]       [0]                                  
                                            =  [c_14(transpose^#(::(@y, @ys)))]                            
                                                                                                           

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) ->
       c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , 6: matrixMult'#1^#(::(@l, @ls), @m2) ->
       c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , 7: transpose^#(@m) -> c_7(transpose#1^#(@m, @m))
  , 8: transpose#1^#(::(@xs, @xss), @m) ->
       c_8(transpose#2^#(split(@m)), split^#(@m))
  , 9: mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys))
  , 10: split^#(@m) -> c_10(split#1^#(@m))
  , 11: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls))
  , 12: split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls))
  , 13: transpose#2^#(tuple#2(@l, @m')) ->
        c_13(transpose#3^#(@m', @l))
  , 14: transpose#3^#(::(@y, @ys), @l) ->
        c_14(transpose^#(::(@y, @ys)))
  , 15: matrixMult^#(@m1, @m2) ->
        c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , 16: matrixMult3^#(@m1, @m2, @m3) ->
        c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 17: matrixMultList^#(@acc, @mm) ->
        c_17(matrixMultList#1^#(@mm, @acc))
  , 18: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),
             matrixMult^#(@acc, @m))
  , 19: matrixMultOld^#(@m1, @m2) ->
        c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }

Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {11}. These cover all (indirect) predecessors of dependency
pairs {11,12,16,19}, their number of application is equally
bounded. The dependency pairs are shifted into the corresponding
weak component(s).


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , transpose^#(@m) -> c_7(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_8(transpose#2^#(split(@m)), split^#(@m))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys))
  , split^#(@m) -> c_10(split#1^#(@m))
  , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_14(transpose^#(::(@y, @ys))) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_17(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.

DPs:
  { 11: transpose#2^#(tuple#2(@l, @m')) ->
        c_13(transpose#3^#(@m', @l))
  , 14: matrixMult3^#(@m1, @m2, @m3) ->
        c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 18: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls)) }
Trs:
  { lineMult#1(nil(), @l) -> nil()
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1, 2},
    Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
    Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1},
    Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1},
    Uargs(c_16) = {1, 2}, Uargs(c_17) = {1}, Uargs(c_18) = {1, 2},
    Uargs(c_19) = {1, 2}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA) and not(IDA(1)).
  
                            [#0] = [0]
                                   [0]
                                      
                      [#abs](x1) = [0]
                                   [0]
                                      
                      [#neg](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                      [#pos](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                        [#s](x1) = [1 0] x1 + [0]
                                   [1 0]      [0]
                                                 
                     [*](x1, x2) = [0]
                                   [0]
                                      
                 [#mult](x1, x2) = [0]
                                   [0]
                                      
                     [+](x1, x2) = [0]
                                   [0]
                                      
                  [#add](x1, x2) = [0]
                                   [0]
                                      
                [attach](x1, x2) = [0 0] x2 + [0]
                                   [0 1]      [1]
                                                 
              [attach#1](x1, x2) = [0 0] x1 + [2 0] x2 + [0]
                                   [0 1]      [2 2]      [2]
                                                            
                    [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1]
                                   [1 0]      [0 1]      [0]
                                                            
          [attach#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0]
                                   [2 2]      [0 0]      [2]
                                                            
                           [nil] = [0]
                                   [0]
                                      
              [lineMult](x1, x2) = [2]
                                   [0]
                                      
            [lineMult#1](x1, x2) = [0 0] x2 + [2]
                                   [0 2]      [0]
                                                 
                  [mult](x1, x2) = [2]
                                   [0]
                                      
                  [makeBase](x1) = [2 0] x1 + [0]
                                   [1 2]      [2]
                                                 
                [makeBase#1](x1) = [0]
                                   [0]
                                      
                    [mkBase](x1) = [0]
                                   [0]
                                      
            [matrixMult](x1, x2) = [0]
                                   [0]
                                      
              [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
           [matrixMult'](x1, x2) = [0]
                                   [0]
                                      
         [matrixMult'#1](x1, x2) = [2 0] x2 + [0]
                                   [0 0]      [0]
                                                 
                 [transpose](x1) = [0]
                                   [0]
                                      
                  [mkBase#1](x1) = [2]
                                   [2]
                                      
                [mult#1](x1, x2) = [2 0] x2 + [0]
                                   [2 2]      [0]
                                                 
            [mult#2](x1, x2, x3) = [2 0] x2 + [0]
                                   [2 0]      [0]
                                                 
                     [split](x1) = [0 2] x1 + [2]
                                   [0 1]      [1]
                                                 
                   [split#1](x1) = [0 1] x1 + [2]
                                   [0 1]      [1]
                                                 
               [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [2]
                                   [1 0]      [0 1]      [1]
                                                            
               [tuple#2](x1, x2) = [0 0] x2 + [2]
                                   [1 1]      [1]
                                                 
           [split#3](x1, x2, x3) = [0 1] x1 + [0 0] x3 + [1]
                                   [0 1]      [1 0]      [1]
                                                            
            [transAcc#1](x1, x2) = [2 0] x2 + [0]
                                   [0 2]      [0]
                                                 
           [transpose#1](x1, x2) = [0]
                                   [0]
                                      
               [transpose#2](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
           [transpose#3](x1, x2) = [0 0] x2 + [2]
                                   [2 0]      [2]
                                                 
                     [#pred](x1) = [0]
                                   [0]
                                      
                     [#succ](x1) = [0 0] x1 + [0]
                                   [2 0]      [0]
                                                 
              [#natmult](x1, x2) = [0]
                                   [0]
                                      
               [#natadd](x1, x2) = [0]
                                   [0]
                                      
                    [#abs^#](x1) = [0]
                                   [0]
                                      
                   [*^#](x1, x2) = [0]
                                   [0]
                                      
               [#mult^#](x1, x2) = [0]
                                   [0]
                                      
                   [+^#](x1, x2) = [0]
                                   [0]
                                      
                [#add^#](x1, x2) = [0]
                                   [0]
                                      
              [attach^#](x1, x2) = [0]
                                   [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                   [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
            [lineMult^#](x1, x2) = [0 0] x2 + [0]
                                   [1 0]      [0]
                                                 
          [lineMult#1^#](x1, x2) = [0 0] x2 + [0]
                                   [2 2]      [0]
                                                 
                [mult^#](x1, x2) = [0 0] x2 + [0]
                                   [1 1]      [1]
                                                 
              [mult#1^#](x1, x2) = [0]
                                   [0]
                                      
                [makeBase^#](x1) = [0]
                                   [0]
                                      
              [makeBase#1^#](x1) = [0]
                                   [0]
                                      
                  [mkBase^#](x1) = [0]
                                   [0]
                                      
                [mkBase#1^#](x1) = [0]
                                   [0]
                                      
          [matrixMult^#](x1, x2) = [0]
                                   [0]
                                      
         [matrixMult'^#](x1, x2) = [0]
                                   [0]
                                      
            [transAcc^#](x1, x2) = [0]
                                   [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMult'#1^#](x1, x2) = [0 0] x2 + [0]
                                   [2 2]      [0]
                                                 
     [matrixMult3^#](x1, x2, x3) = [2 0] x1 + [2 0] x2 + [1 0] x3 + [2]
                                   [2 2]      [1 1]      [1 1]      [2]
                                                                       
      [matrixMultList^#](x1, x2) = [0]
                                   [0]
                                      
    [matrixMultList#1^#](x1, x2) = [0 0] x2 + [0]
                                   [2 2]      [0]
                                                 
       [matrixMultOld^#](x1, x2) = [2 0] x1 + [1 2] x2 + [2]
                                   [2 1]      [1 2]      [2]
                                                            
               [transpose^#](x1) = [1 2] x1 + [2]
                                   [0 0]      [0]
                                                 
         [transpose#1^#](x1, x2) = [1 2] x2 + [2]
                                   [0 0]      [1]
                                                 
          [mult#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
                   [split^#](x1) = [1 0] x1 + [0]
                                   [1 0]      [1]
                                                 
                 [split#1^#](x1) = [1 0] x1 + [0]
                                   [0 0]      [1]
                                                 
             [split#2^#](x1, x2) = [1 0] x2 + [0]
                                   [0 0]      [0]
                                                 
         [split#3^#](x1, x2, x3) = [0]
                                   [0]
                                      
             [transpose#2^#](x1) = [0 2] x1 + [0]
                                   [0 1]      [0]
                                                 
         [transpose#3^#](x1, x2) = [2 2] x1 + [1]
                                   [0 0]      [1]
                                                 
              [transpose'^#](x1) = [0]
                                   [0]
                                      
            [#natmult^#](x1, x2) = [0]
                                   [0]
                                      
                   [#pred^#](x1) = [0]
                                   [0]
                                      
                   [#succ^#](x1) = [0]
                                   [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                       [c_2](x1) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                   [c_5](x1, x2) = [0]
                                   [0]
                                      
                       [c_6](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                       [c_8](x1) = [0]
                                   [0]
                                      
                       [c_9](x1) = [0]
                                   [0]
                                      
                      [c_10](x1) = [0]
                                   [0]
                                      
                      [c_11](x1) = [0]
                                   [0]
                                      
              [c_12](x1, x2, x3) = [0]
                                   [0]
                                      
                      [c_13](x1) = [0]
                                   [0]
                                      
                      [c_14](x1) = [0]
                                   [0]
                                      
                  [c_15](x1, x2) = [0]
                                   [0]
                                      
                  [c_16](x1, x2) = [0]
                                   [0]
                                      
                  [c_17](x1, x2) = [0]
                                   [0]
                                      
                      [c_18](x1) = [0]
                                   [0]
                                      
                  [c_19](x1, x2) = [0]
                                   [0]
                                      
                  [c_20](x1, x2) = [0]
                                   [0]
                                      
                      [c_21](x1) = [0]
                                   [0]
                                      
                  [c_22](x1, x2) = [0]
                                   [0]
                                      
                      [c_23](x1) = [0]
                                   [0]
                                      
                      [c_24](x1) = [0]
                                   [0]
                                      
                      [c_25](x1) = [0]
                                   [0]
                                      
                      [c_26](x1) = [0]
                                   [0]
                                      
                      [c_27](x1) = [0]
                                   [0]
                                      
                      [c_28](x1) = [0]
                                   [0]
                                      
                  [c_29](x1, x2) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                   [c_2](x1, x2) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                       [c_5](x1) = [0]
                                   [0]
                                      
                       [c_6](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                       [c_8](x1) = [0]
                                   [0]
                                      
                       [c_9](x1) = [0]
                                   [0]
                                      
                  [c_10](x1, x2) = [0]
                                   [0]
                                      
                      [c_11](x1) = [0]
                                   [0]
                                      
                  [c_12](x1, x2) = [0]
                                   [0]
                                      
                      [c_13](x1) = [0]
                                   [0]
                                      
                      [c_14](x1) = [0]
                                   [0]
                                      
                      [c_15](x1) = [0]
                                   [0]
                                      
                      [c_16](x1) = [0]
                                   [0]
                                      
                      [c_17](x1) = [0]
                                   [0]
                                      
                      [c_18](x1) = [0]
                                   [0]
                                      
                      [c_19](x1) = [0]
                                   [0]
                                      
                      [c_20](x1) = [0]
                                   [0]
                                      
              [c_21](x1, x2, x3) = [0]
                                   [0]
                                      
                  [c_22](x1, x2) = [0]
                                   [0]
                                      
                      [c_23](x1) = [0]
                                   [0]
                                      
                  [c_24](x1, x2) = [0]
                                   [0]
                                      
                  [c_25](x1, x2) = [0]
                                   [0]
                                      
                  [c_26](x1, x2) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                   [c_2](x1, x2) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                       [c_5](x1) = [0]
                                   [0]
                                      
                       [c_6](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                   [c_8](x1, x2) = [0]
                                   [0]
                                      
                       [c_9](x1) = [0]
                                   [0]
                                      
                  [c_10](x1, x2) = [0]
                                   [0]
                                      
                      [c_11](x1) = [0]
                                   [0]
                                      
                      [c_12](x1) = [0]
                                   [0]
                                      
                      [c_13](x1) = [0]
                                   [0]
                                      
                      [c_14](x1) = [0]
                                   [0]
                                      
                      [c_15](x1) = [0]
                                   [0]
                                      
                      [c_16](x1) = [0]
                                   [0]
                                      
                  [c_17](x1, x2) = [0]
                                   [0]
                                      
                  [c_18](x1, x2) = [0]
                                   [0]
                                      
                      [c_19](x1) = [0]
                                   [0]
                                      
                  [c_20](x1, x2) = [0]
                                   [0]
                                      
                  [c_21](x1, x2) = [0]
                                   [0]
                                      
                      [c_22](x1) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_2](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_3](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_4](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_5](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_6](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_7](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_8](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_9](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_10](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_11](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_12](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_13](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_14](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_15](x1) = [2 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                  [c_16](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [1]
                                                            
                      [c_17](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                  [c_18](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                  [c_19](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 0]      [0]
  
  This order satisfies following ordering constraints
  
                                [split(@m)] =  [0 2] @m + [2]                                              
                                               [0 1]      [1]                                              
                                            >= [0 1] @m + [2]                                              
                                               [0 1]      [1]                                              
                                            =  [split#1(@m)]                                               
                                                                                                           
                     [split#1(::(@l, @ls))] =  [1 0] @l + [0 1] @ls + [2]                                  
                                               [1 0]      [0 1]       [1]                                  
                                            >= [0 0] @l + [0 1] @ls + [2]                                  
                                               [1 0]      [0 1]       [1]                                  
                                            =  [split#2(@l, @ls)]                                          
                                                                                                           
                           [split#1(nil())] =  [2]                                                         
                                               [1]                                                         
                                            >= [2]                                                         
                                               [1]                                                         
                                            =  [tuple#2(nil(), nil())]                                     
                                                                                                           
                [split#2(::(@x, @xs), @ls)] =  [0 1] @ls + [0 0] @xs + [2]                                 
                                               [0 1]       [1 0]       [2]                                 
                                            >= [0 1] @ls + [0 0] @xs + [2]                                 
                                               [0 1]       [1 0]       [2]                                 
                                            =  [split#3(split(@ls), @x, @xs)]                              
                                                                                                           
                      [split#2(nil(), @ls)] =  [0 1] @ls + [2]                                             
                                               [0 1]       [1]                                             
                                            >= [2]                                                         
                                               [1]                                                         
                                            =  [tuple#2(nil(), nil())]                                     
                                                                                                           
      [split#3(tuple#2(@ys, @m'), @x, @xs)] =  [1 1] @m' + [0 0] @xs + [2]                                 
                                               [1 1]       [1 0]       [2]                                 
                                            >= [0 0] @m' + [0 0] @xs + [2]                                 
                                               [1 1]       [1 0]       [2]                                 
                                            =  [tuple#2(::(@x, @ys), ::(@xs, @m'))]                        
                                                                                                           
                      [lineMult^#(@l, @m2)] =  [0 0] @m2 + [0]                                             
                                               [1 0]       [0]                                             
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_1(lineMult#1^#(@m2, @l))]                                
                                                                                                           
            [lineMult#1^#(::(@x, @xs), @l)] =  [0 0] @l + [0]                                              
                                               [2 2]      [0]                                              
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))]                  
                                                                                                           
                         [mult^#(@l1, @l2)] =  [0 0] @l2 + [0]                                             
                                               [1 1]       [1]                                             
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_3(mult#1^#(@l1, @l2))]                                   
                                                                                                           
               [mult#1^#(::(@x, @xs), @l2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_4(mult#2^#(@l2, @x, @xs))]                               
                                                                                                           
                   [matrixMult^#(@m1, @m2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))]    
                                                                                                           
                  [matrixMult'^#(@m1, @m2)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_5(matrixMult'#1^#(@m1, @m2))]                            
                                                                                                           
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0 0] @m2 + [0]                                             
                                               [2 2]       [0]                                             
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))]         
                                                                                                           
             [matrixMult3^#(@m1, @m2, @m3)] =  [2 0] @m1 + [2 0] @m2 + [1 0] @m3 + [2]                     
                                               [2 2]       [1 1]       [1 1]       [2]                     
                                            >  [0]                                                         
                                               [1]                                                         
                                            =  [c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),              
                                                     matrixMult^#(@m1, @m2))]                              
                                                                                                           
              [matrixMultList^#(@acc, @mm)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_17(matrixMultList#1^#(@mm, @acc))]                       
                                                                                                           
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [0 0] @acc + [0]                                            
                                               [2 2]        [0]                                            
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),          
                                                     matrixMult^#(@acc, @m))]                              
                                                                                                           
                [matrixMultOld^#(@m1, @m2)] =  [2 0] @m1 + [1 2] @m2 + [2]                                 
                                               [2 1]       [1 2]       [2]                                 
                                            >= [1 2] @m2 + [2]                                             
                                               [0 0]       [0]                                             
                                            =  [c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))]
                                                                                                           
                          [transpose^#(@m)] =  [1 2] @m + [2]                                              
                                               [0 0]      [0]                                              
                                            >= [1 2] @m + [2]                                              
                                               [0 0]      [0]                                              
                                            =  [c_7(transpose#1^#(@m, @m))]                                
                                                                                                           
         [transpose#1^#(::(@xs, @xss), @m)] =  [1 2] @m + [2]                                              
                                               [0 0]      [1]                                              
                                            >= [1 2] @m + [2]                                              
                                               [0 0]      [0]                                              
                                            =  [c_8(transpose#2^#(split(@m)), split^#(@m))]                
                                                                                                           
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0]                                                         
                                               [0]                                                         
                                            >= [0]                                                         
                                               [0]                                                         
                                            =  [c_9(mult^#(@xs, @ys))]                                     
                                                                                                           
                              [split^#(@m)] =  [1 0] @m + [0]                                              
                                               [1 0]      [1]                                              
                                            >= [1 0] @m + [0]                                              
                                               [0 0]      [0]                                              
                                            =  [c_10(split#1^#(@m))]                                       
                                                                                                           
                   [split#1^#(::(@l, @ls))] =  [1 0] @ls + [1]                                             
                                               [0 0]       [1]                                             
                                            >  [1 0] @ls + [0]                                             
                                               [0 0]       [0]                                             
                                            =  [c_11(split#2^#(@l, @ls))]                                  
                                                                                                           
              [split#2^#(::(@x, @xs), @ls)] =  [1 0] @ls + [0]                                             
                                               [0 0]       [0]                                             
                                            >= [1 0] @ls + [0]                                             
                                               [0 0]       [0]                                             
                                            =  [c_12(split^#(@ls))]                                        
                                                                                                           
          [transpose#2^#(tuple#2(@l, @m'))] =  [2 2] @m' + [2]                                             
                                               [1 1]       [1]                                             
                                            >  [2 2] @m' + [1]                                             
                                               [0 0]       [0]                                             
                                            =  [c_13(transpose#3^#(@m', @l))]                              
                                                                                                           
           [transpose#3^#(::(@y, @ys), @l)] =  [2 0] @y + [2 2] @ys + [3]                                  
                                               [0 0]      [0 0]       [1]                                  
                                            >= [2 0] @y + [1 2] @ys + [3]                                  
                                               [0 0]      [0 0]       [0]                                  
                                            =  [c_14(transpose^#(::(@y, @ys)))]                            
                                                                                                           

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) ->
       c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , 5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , 6: matrixMult'#1^#(::(@l, @ls), @m2) ->
       c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , 7: transpose^#(@m) -> c_7(transpose#1^#(@m, @m))
  , 8: transpose#1^#(::(@xs, @xss), @m) ->
       c_8(transpose#2^#(split(@m)), split^#(@m))
  , 9: mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys))
  , 10: split^#(@m) -> c_10(split#1^#(@m))
  , 11: transpose#2^#(tuple#2(@l, @m')) ->
        c_13(transpose#3^#(@m', @l))
  , 12: transpose#3^#(::(@y, @ys), @l) ->
        c_14(transpose^#(::(@y, @ys)))
  , 13: matrixMult^#(@m1, @m2) ->
        c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , 14: matrixMult3^#(@m1, @m2, @m3) ->
        c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
             matrixMult^#(@m1, @m2))
  , 15: matrixMultList^#(@acc, @mm) ->
        c_17(matrixMultList#1^#(@mm, @acc))
  , 16: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),
             matrixMult^#(@acc, @m))
  , 17: matrixMultOld^#(@m1, @m2) ->
        c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , 18: split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls))
  , 19: split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls)) }

Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {11,14,18}. These cover all (indirect) predecessors of
dependency pairs {7,8,10,11,12,14,17,18,19}, their number of
application is equally bounded. The dependency pairs are shifted
into the corresponding weak component(s).

We apply the transformation 'removetails' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_17(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2))
  , transpose^#(@m) -> c_7(transpose#1^#(@m, @m))
  , transpose#1^#(::(@xs, @xss), @m) ->
    c_8(transpose#2^#(split(@m)), split^#(@m))
  , split^#(@m) -> c_10(split#1^#(@m))
  , split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls))
  , split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls))
  , transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l))
  , transpose#3^#(::(@y, @ys), @l) ->
    c_14(transpose^#(::(@y, @ys))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ transpose^#(@m) -> c_7(transpose#1^#(@m, @m))
, transpose#1^#(::(@xs, @xss), @m) ->
  c_8(transpose#2^#(split(@m)), split^#(@m))
, split^#(@m) -> c_10(split#1^#(@m))
, split#1^#(::(@l, @ls)) -> c_11(split#2^#(@l, @ls))
, split#2^#(::(@x, @xs), @ls) -> c_12(split^#(@ls))
, transpose#2^#(tuple#2(@l, @m')) -> c_13(transpose#3^#(@m', @l))
, transpose#3^#(::(@y, @ys), @l) ->
  c_14(transpose^#(::(@y, @ys))) }

We apply the transformation 'simpDPRHS' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_9(mult^#(@xs, @ys)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_15(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_16(matrixMult^#(matrixMult(@m1, @m2), @m3),
         matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_17(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_18(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { matrixMultOld^#(@m1, @m2) ->
    c_19(matrixMult'^#(@m1, transpose(@m2)), transpose^#(@m2)) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_9(matrixMult^#(matrixMult(@m1, @m2), @m3),
        matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_10(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_11(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_12(matrixMult'^#(@m1, transpose(@m2))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^3))

We decompose the input problem according to the dependency graph
into the upper component

  { matrixMult3^#(@m1, @m2, @m3) ->
    c_9(matrixMult^#(matrixMult(@m1, @m2), @m3),
        matrixMult^#(@m1, @m2))
  , matrixMultList^#(@acc, @mm) ->
    c_10(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_11(matrixMultList^#(matrixMult(@acc, @m), @ms),
         matrixMult^#(@acc, @m))
  , matrixMultOld^#(@m1, @m2) ->
    c_12(matrixMult'^#(@m1, transpose(@m2))) }

and lower component

  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult^#(@m1, @m2) ->
    c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }

Further, following extension rules are added to the lower
component.

{ matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2)
, matrixMult3^#(@m1, @m2, @m3) ->
  matrixMult^#(matrixMult(@m1, @m2), @m3)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
  matrixMultList^#(matrixMult(@acc, @m), @ms)
, matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }

TcT solves the upper component with certificate YES(O(1),O(n^1)).

Sub-proof:
----------
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(n^1)).
  
  Strict DPs:
    { matrixMult3^#(@m1, @m2, @m3) ->
      c_9(matrixMult^#(matrixMult(@m1, @m2), @m3),
          matrixMult^#(@m1, @m2))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_11(matrixMultList^#(matrixMult(@acc, @m), @ms),
           matrixMult^#(@acc, @m))
    , matrixMultOld^#(@m1, @m2) ->
      c_12(matrixMult'^#(@m1, transpose(@m2))) }
  Weak DPs:
    { matrixMultList^#(@acc, @mm) ->
      c_10(matrixMultList#1^#(@mm, @acc)) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(n^1))
  
  Due to missing edges in the dependency-graph, the right-hand sides
  of following rules could be simplified:
  
    { matrixMult3^#(@m1, @m2, @m3) ->
      c_9(matrixMult^#(matrixMult(@m1, @m2), @m3),
          matrixMult^#(@m1, @m2))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_11(matrixMultList^#(matrixMult(@acc, @m), @ms),
           matrixMult^#(@acc, @m))
    , matrixMultOld^#(@m1, @m2) ->
      c_12(matrixMult'^#(@m1, transpose(@m2))) }
  
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(n^1)).
  
  Strict DPs:
    { matrixMult3^#(@m1, @m2, @m3) -> c_1()
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_2(matrixMultList^#(matrixMult(@acc, @m), @ms))
    , matrixMultOld^#(@m1, @m2) -> c_3() }
  Weak DPs:
    { matrixMultList^#(@acc, @mm) ->
      c_4(matrixMultList#1^#(@mm, @acc)) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(n^1))
  
  Consider the dependency graph
  
    1: matrixMult3^#(@m1, @m2, @m3) -> c_1()
    
    2: matrixMultList#1^#(::(@m, @ms), @acc) ->
       c_2(matrixMultList^#(matrixMult(@acc, @m), @ms))
       -->_1 matrixMultList^#(@acc, @mm) ->
             c_4(matrixMultList#1^#(@mm, @acc)) :4
    
    3: matrixMultOld^#(@m1, @m2) -> c_3()
    
    4: matrixMultList^#(@acc, @mm) ->
       c_4(matrixMultList#1^#(@mm, @acc))
       -->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
             c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) :2
    
  
  Following roots of the dependency graph are removed, as the
  considered set of starting terms is closed under reduction with
  respect to these rules (modulo compound contexts).
  
    { matrixMult3^#(@m1, @m2, @m3) -> c_1()
    , matrixMultOld^#(@m1, @m2) -> c_3() }
  
  
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(n^1)).
  
  Strict DPs:
    { matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) }
  Weak DPs:
    { matrixMultList^#(@acc, @mm) ->
      c_4(matrixMultList#1^#(@mm, @acc)) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(n^1))
  
  We replace rewrite rules by usable rules:
  
    Weak Usable Rules:
      { #abs(#0()) -> #0()
      , #abs(#neg(@x)) -> #pos(@x)
      , #abs(#pos(@x)) -> #pos(@x)
      , #abs(#s(@x)) -> #pos(#s(@x))
      , *(@x, @y) -> #mult(@x, @y)
      , #mult(#0(), #0()) -> #0()
      , #mult(#0(), #neg(@y)) -> #0()
      , #mult(#0(), #pos(@y)) -> #0()
      , #mult(#neg(@x), #0()) -> #0()
      , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
      , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
      , #mult(#pos(@x), #0()) -> #0()
      , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
      , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
      , +(@x, @y) -> #add(@x, @y)
      , #add(#0(), @y) -> @y
      , #add(#neg(#s(#0())), @y) -> #pred(@y)
      , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
      , #add(#pos(#s(#0())), @y) -> #succ(@y)
      , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
      , attach(@line, @m) -> attach#1(@line, @m)
      , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
      , attach#1(nil(), @m) -> nil()
      , attach#2(::(@l, @ls), @x, @xs) ->
        ::(::(@x, @l), attach(@xs, @ls))
      , attach#2(nil(), @x, @xs) -> nil()
      , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
      , lineMult#1(::(@x, @xs), @l) ->
        ::(mult(@l, @x), lineMult(@l, @xs))
      , lineMult#1(nil(), @l) -> nil()
      , mult(@l1, @l2) -> mult#1(@l1, @l2)
      , makeBase(@m) -> makeBase#1(@m)
      , makeBase#1(::(@l, @m')) -> mkBase(@l)
      , makeBase#1(nil()) -> nil()
      , mkBase(@m) -> mkBase#1(@m)
      , matrixMult(@m1, @m2) ->
        matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
      , transAcc(@m, @base) -> transAcc#1(@m, @base)
      , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
      , matrixMult'#1(::(@l, @ls), @m2) ->
        ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
      , matrixMult'#1(nil(), @m2) -> nil()
      , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
      , mkBase#1(nil()) -> nil()
      , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
      , mult#1(nil(), @l2) -> #abs(#0())
      , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
      , mult#2(nil(), @x, @xs) -> #abs(#0())
      , transAcc#1(::(@l, @m'), @base) ->
        attach(@l, transAcc(@m', @base))
      , transAcc#1(nil(), @base) -> @base
      , #pred(#0()) -> #neg(#s(#0()))
      , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
      , #pred(#pos(#s(#0()))) -> #0()
      , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
      , #succ(#0()) -> #pos(#s(#0()))
      , #succ(#neg(#s(#0()))) -> #0()
      , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
      , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
      , #natmult(#0(), @y) -> #0()
      , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
      , #natadd(#0(), @y) -> @y
      , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(n^1)).
  
  Strict DPs:
    { matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) }
  Weak DPs:
    { matrixMultList^#(@acc, @mm) ->
      c_4(matrixMultList#1^#(@mm, @acc)) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(n^1))
  
  We use the processor 'matrix interpretation of dimension 1' to
  orient following rules strictly.
  
  DPs:
    { 1: matrixMultList#1^#(::(@m, @ms), @acc) ->
         c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) }
  Trs:
    { attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base }
  
  Sub-proof:
  ----------
    The following argument positions are usable:
      Uargs(c_2) = {1}, Uargs(c_4) = {1}
    
    TcT has computed following constructor-based matrix interpretation
    satisfying not(EDA).
    
                              [#0] = [0]
                                        
                        [#abs](x1) = [0]
                                        
                        [#neg](x1) = [0]
                                        
                        [#pos](x1) = [0]
                                        
                          [#s](x1) = [0]
                                        
                       [*](x1, x2) = [0]
                                        
                   [#mult](x1, x2) = [0]
                                        
                       [+](x1, x2) = [0]
                                        
                    [#add](x1, x2) = [1] x2 + [0]
                                                 
                  [attach](x1, x2) = [0]
                                        
                [attach#1](x1, x2) = [1] x1 + [1]
                                                 
                      [::](x1, x2) = [1] x2 + [1]
                                                 
            [attach#2](x1, x2, x3) = [0]
                                        
                             [nil] = [0]
                                        
                [lineMult](x1, x2) = [0]
                                        
              [lineMult#1](x1, x2) = [0]
                                        
                    [mult](x1, x2) = [0]
                                        
                    [makeBase](x1) = [0]
                                        
                  [makeBase#1](x1) = [1]
                                        
                      [mkBase](x1) = [0]
                                        
              [matrixMult](x1, x2) = [1] x1 + [1]
                                                 
                [transAcc](x1, x2) = [0]
                                        
             [matrixMult'](x1, x2) = [0]
                                        
           [matrixMult'#1](x1, x2) = [1] x1 + [0]
                                                 
                   [transpose](x1) = [0]
                                        
                    [mkBase#1](x1) = [0]
                                        
                  [mult#1](x1, x2) = [1]
                                        
              [mult#2](x1, x2, x3) = [0]
                                        
                       [split](x1) = [0]
                                        
                     [split#1](x1) = [0]
                                        
                 [split#2](x1, x2) = [0]
                                        
                 [tuple#2](x1, x2) = [0]
                                        
             [split#3](x1, x2, x3) = [0]
                                        
              [transAcc#1](x1, x2) = [1] x2 + [1]
                                                 
             [transpose#1](x1, x2) = [0]
                                        
                 [transpose#2](x1) = [0]
                                        
             [transpose#3](x1, x2) = [0]
                                        
                       [#pred](x1) = [0]
                                        
                       [#succ](x1) = [0]
                                        
                [#natmult](x1, x2) = [0]
                                        
                 [#natadd](x1, x2) = [1] x2 + [0]
                                                 
                      [#abs^#](x1) = [0]
                                        
                     [*^#](x1, x2) = [0]
                                        
                 [#mult^#](x1, x2) = [0]
                                        
                     [+^#](x1, x2) = [0]
                                        
                  [#add^#](x1, x2) = [0]
                                        
                [attach^#](x1, x2) = [0]
                                        
              [attach#1^#](x1, x2) = [0]
                                        
          [attach#2^#](x1, x2, x3) = [0]
                                        
              [lineMult^#](x1, x2) = [0]
                                        
            [lineMult#1^#](x1, x2) = [0]
                                        
                  [mult^#](x1, x2) = [0]
                                        
                [mult#1^#](x1, x2) = [0]
                                        
                  [makeBase^#](x1) = [0]
                                        
                [makeBase#1^#](x1) = [0]
                                        
                    [mkBase^#](x1) = [0]
                                        
                  [mkBase#1^#](x1) = [0]
                                        
            [matrixMult^#](x1, x2) = [0]
                                        
           [matrixMult'^#](x1, x2) = [0]
                                        
              [transAcc^#](x1, x2) = [0]
                                        
            [transAcc#1^#](x1, x2) = [0]
                                        
         [matrixMult'#1^#](x1, x2) = [0]
                                        
       [matrixMult3^#](x1, x2, x3) = [0]
                                        
        [matrixMultList^#](x1, x2) = [1] x2 + [0]
                                                 
      [matrixMultList#1^#](x1, x2) = [1] x1 + [0]
                                                 
         [matrixMultOld^#](x1, x2) = [0]
                                        
                 [transpose^#](x1) = [0]
                                        
           [transpose#1^#](x1, x2) = [0]
                                        
            [mult#2^#](x1, x2, x3) = [0]
                                        
                     [split^#](x1) = [0]
                                        
                   [split#1^#](x1) = [0]
                                        
               [split#2^#](x1, x2) = [0]
                                        
           [split#3^#](x1, x2, x3) = [0]
                                        
               [transpose#2^#](x1) = [0]
                                        
           [transpose#3^#](x1, x2) = [0]
                                        
                [transpose'^#](x1) = [0]
                                        
              [#natmult^#](x1, x2) = [0]
                                        
                     [#pred^#](x1) = [0]
                                        
                     [#succ^#](x1) = [0]
                                        
               [#natadd^#](x1, x2) = [0]
                                        
                     [c_9](x1, x2) = [0]
                                        
                        [c_10](x1) = [0]
                                        
                    [c_11](x1, x2) = [0]
                                        
                        [c_12](x1) = [0]
                                        
                               [c] = [0]
                                        
                             [c_1] = [0]
                                        
                         [c_2](x1) = [1] x1 + [0]
                                                 
                             [c_3] = [0]
                                        
                         [c_4](x1) = [1] x1 + [0]
    
    This order satisfies following ordering constraints
    
                         [#natmult(#0(), @y)] =  [0]                                               
                                              >= [0]                                               
                                              =  [#0()]                                            
                                                                                                   
                       [#natmult(#s(@x), @y)] =  [0]                                               
                                              >= [0]                                               
                                              =  [#natadd(@y, #natmult(@x, @y))]                   
                                                                                                   
                          [#natadd(#0(), @y)] =  [1] @y + [0]                                      
                                              >= [1] @y + [0]                                      
                                              =  [@y]                                              
                                                                                                   
                        [#natadd(#s(@x), @y)] =  [1] @y + [0]                                      
                                              >= [0]                                               
                                              =  [#s(#natadd(@x, @y))]                             
                                                                                                   
                [matrixMultList^#(@acc, @mm)] =  [1] @mm + [0]                                     
                                              >= [1] @mm + [0]                                     
                                              =  [c_4(matrixMultList#1^#(@mm, @acc))]              
                                                                                                   
      [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1] @ms + [1]                                     
                                              >  [1] @ms + [0]                                     
                                              =  [c_2(matrixMultList^#(matrixMult(@acc, @m), @ms))]
                                                                                                   
  
  Consider the set of all dependency pairs
  
  DPs:
    { 1: matrixMultList#1^#(::(@m, @ms), @acc) ->
         c_2(matrixMultList^#(matrixMult(@acc, @m), @ms))
    , 2: matrixMultList^#(@acc, @mm) ->
         c_4(matrixMultList#1^#(@mm, @acc)) }
  
  Processor 'matrix interpretation of dimension 1' induces the
  complexity certificate YES(?,O(n^1)) on application of dependency
  pairs {1}. These cover all (indirect) predecessors of dependency
  pairs {1,2}, their number of application is equally bounded. The
  dependency pairs are shifted into the corresponding weak
  component(s).
  
  We apply the transformation 'removetails' on the sub-problem:
  
  Weak DPs:
    { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  StartTerms: basic terms
  Strategy: innermost
  
  The following weak DPs constitute a sub-graph of the DG that is
  closed under successors. The DPs are removed.
  
  { matrixMultList^#(@acc, @mm) -> c_4(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_2(matrixMultList^#(matrixMult(@acc, @m), @ms)) }
  
  
  We apply the transformation 'usablerules' on the sub-problem:
  
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  StartTerms: basic terms
  Strategy: innermost
  
  No rule is usable, rules are removed from the input problem.
  
  
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(1)).
  
  Rules: Empty
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(1))
  
  Empty rules are trivially bounded

We return to the main proof.

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2)
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

Consider the dependency graph

  1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
     -->_1 lineMult#1^#(::(@x, @xs), @l) ->
           c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) :2
  
  2: lineMult#1^#(::(@x, @xs), @l) ->
     c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
     -->_1 mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) :3
     -->_2 lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) :1
  
  3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
     -->_1 mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) :4
  
  4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
     -->_1 mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) :7
  
  5: matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
     -->_1 matrixMult'#1^#(::(@l, @ls), @m2) ->
           c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) :6
  
  6: matrixMult'#1^#(::(@l, @ls), @m2) ->
     c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
     -->_2 matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) :5
     -->_1 lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) :1
  
  7: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys))
     -->_1 mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2)) :3
  
  8: matrixMult^#(@m1, @m2) ->
     c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
     -->_1 matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) :5
  
  9: matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2)
     -->_1 matrixMult^#(@m1, @m2) ->
           c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) :8
  
  10: matrixMult3^#(@m1, @m2, @m3) ->
      matrixMult^#(matrixMult(@m1, @m2), @m3)
     -->_1 matrixMult^#(@m1, @m2) ->
           c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) :8
  
  11: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
     -->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
           matrixMultList^#(matrixMult(@acc, @m), @ms) :13
     -->_1 matrixMultList#1^#(::(@m, @ms), @acc) ->
           matrixMult^#(@acc, @m) :12
  
  12: matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
     -->_1 matrixMult^#(@m1, @m2) ->
           c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))) :8
  
  13: matrixMultList#1^#(::(@m, @ms), @acc) ->
      matrixMultList^#(matrixMult(@acc, @m), @ms)
     -->_1 matrixMultList^#(@acc, @mm) ->
           matrixMultList#1^#(@mm, @acc) :11
  
  14: matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2))
     -->_1 matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2)) :5
  

Following roots of the dependency graph are removed, as the
considered set of starting terms is closed under reduction with
respect to these rules (modulo compound contexts).

  { matrixMult3^#(@m1, @m2, @m3) -> matrixMult^#(@m1, @m2) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

We decompose the input problem according to the dependency graph
into the upper component

  { matrixMult^#(@m1, @m2) ->
    c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) ->
    c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }

and lower component

  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }

Further, following extension rules are added to the lower
component.

{ matrixMult^#(@m1, @m2) ->
  matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
, matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
, matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
, matrixMult3^#(@m1, @m2, @m3) ->
  matrixMult^#(matrixMult(@m1, @m2), @m3)
, matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
, matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
, matrixMultList#1^#(::(@m, @ms), @acc) ->
  matrixMultList^#(matrixMult(@acc, @m), @ms)
, matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }

TcT solves the upper component with certificate YES(O(1),O(n^1)).

Sub-proof:
----------
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(n^1)).
  
  Strict DPs:
    { matrixMult'^#(@m1, @m2) -> c_5(matrixMult'#1^#(@m1, @m2))
    , matrixMult'#1^#(::(@l, @ls), @m2) ->
      c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) }
  Weak DPs:
    { matrixMult^#(@m1, @m2) ->
      c_8(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
    , matrixMult3^#(@m1, @m2, @m3) ->
      matrixMult^#(matrixMult(@m1, @m2), @m3)
    , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
    , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      matrixMultList^#(matrixMult(@acc, @m), @ms)
    , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(n^1))
  
  Due to missing edges in the dependency-graph, the right-hand sides
  of following rules could be simplified:
  
    { matrixMult'#1^#(::(@l, @ls), @m2) ->
      c_6(lineMult^#(@l, @m2), matrixMult'^#(@ls, @m2)) }
  
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(n^1)).
  
  Strict DPs:
    { matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2))
    , matrixMult'#1^#(::(@l, @ls), @m2) ->
      c_2(matrixMult'^#(@ls, @m2)) }
  Weak DPs:
    { matrixMult^#(@m1, @m2) ->
      c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
    , matrixMult3^#(@m1, @m2, @m3) ->
      c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))
    , matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_6(matrixMult^#(@acc, @m))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_7(matrixMultList^#(matrixMult(@acc, @m), @ms))
    , matrixMultOld^#(@m1, @m2) ->
      c_8(matrixMult'^#(@m1, transpose(@m2))) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(n^1))
  
  We use the processor 'matrix interpretation of dimension 1' to
  orient following rules strictly.
  
  DPs:
    { 2: matrixMult'#1^#(::(@l, @ls), @m2) ->
         c_2(matrixMult'^#(@ls, @m2))
    , 4: matrixMult3^#(@m1, @m2, @m3) ->
         c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))
    , 6: matrixMultList#1^#(::(@m, @ms), @acc) ->
         c_6(matrixMult^#(@acc, @m)) }
  Trs:
    { transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base }
  
  Sub-proof:
  ----------
    The following argument positions are usable:
      Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
      Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
      Uargs(c_7) = {1}, Uargs(c_8) = {1}
    
    TcT has computed following constructor-based matrix interpretation
    satisfying not(EDA).
    
                              [#0] = [0]
                                        
                        [#abs](x1) = [0]
                                        
                        [#neg](x1) = [1] x1 + [0]
                                                 
                        [#pos](x1) = [0]
                                        
                          [#s](x1) = [0]
                                        
                       [*](x1, x2) = [0]
                                        
                   [#mult](x1, x2) = [1] x1 + [0]
                                                 
                       [+](x1, x2) = [1] x1 + [1] x2 + [0]
                                                          
                    [#add](x1, x2) = [1] x1 + [1] x2 + [0]
                                                          
                  [attach](x1, x2) = [0]
                                        
                [attach#1](x1, x2) = [0]
                                        
                      [::](x1, x2) = [1] x2 + [1]
                                                 
            [attach#2](x1, x2, x3) = [0]
                                        
                             [nil] = [0]
                                        
                [lineMult](x1, x2) = [0]
                                        
              [lineMult#1](x1, x2) = [0]
                                        
                    [mult](x1, x2) = [0]
                                        
                    [makeBase](x1) = [0]
                                        
                  [makeBase#1](x1) = [0]
                                        
                      [mkBase](x1) = [0]
                                        
              [matrixMult](x1, x2) = [1] x1 + [0]
                                                 
                [transAcc](x1, x2) = [1]
                                        
             [matrixMult'](x1, x2) = [1] x1 + [0]
                                                 
           [matrixMult'#1](x1, x2) = [1] x1 + [0]
                                                 
                   [transpose](x1) = [0]
                                        
                    [mkBase#1](x1) = [0]
                                        
                  [mult#1](x1, x2) = [0]
                                        
              [mult#2](x1, x2, x3) = [0]
                                        
                       [split](x1) = [0]
                                        
                     [split#1](x1) = [0]
                                        
                 [split#2](x1, x2) = [0]
                                        
                 [tuple#2](x1, x2) = [1] x2 + [0]
                                                 
             [split#3](x1, x2, x3) = [0]
                                        
              [transAcc#1](x1, x2) = [1] x2 + [1]
                                                 
             [transpose#1](x1, x2) = [0]
                                        
                 [transpose#2](x1) = [0]
                                        
             [transpose#3](x1, x2) = [0]
                                        
                       [#pred](x1) = [0]
                                        
                       [#succ](x1) = [0]
                                        
                [#natmult](x1, x2) = [0]
                                        
                 [#natadd](x1, x2) = [0]
                                        
                      [#abs^#](x1) = [0]
                                        
                     [*^#](x1, x2) = [0]
                                        
                 [#mult^#](x1, x2) = [0]
                                        
                     [+^#](x1, x2) = [0]
                                        
                  [#add^#](x1, x2) = [0]
                                        
                [attach^#](x1, x2) = [0]
                                        
              [attach#1^#](x1, x2) = [0]
                                        
          [attach#2^#](x1, x2, x3) = [0]
                                        
              [lineMult^#](x1, x2) = [0]
                                        
            [lineMult#1^#](x1, x2) = [0]
                                        
                  [mult^#](x1, x2) = [0]
                                        
                [mult#1^#](x1, x2) = [0]
                                        
                  [makeBase^#](x1) = [0]
                                        
                [makeBase#1^#](x1) = [0]
                                        
                    [mkBase^#](x1) = [0]
                                        
                  [mkBase#1^#](x1) = [0]
                                        
            [matrixMult^#](x1, x2) = [1] x1 + [0]
                                                 
           [matrixMult'^#](x1, x2) = [1] x1 + [0]
                                                 
              [transAcc^#](x1, x2) = [0]
                                        
            [transAcc#1^#](x1, x2) = [0]
                                        
         [matrixMult'#1^#](x1, x2) = [1] x1 + [0]
                                                 
       [matrixMult3^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                   
        [matrixMultList^#](x1, x2) = [1] x1 + [1]
                                                 
      [matrixMultList#1^#](x1, x2) = [1] x2 + [1]
                                                 
         [matrixMultOld^#](x1, x2) = [1] x1 + [1] x2 + [1]
                                                          
                 [transpose^#](x1) = [0]
                                        
           [transpose#1^#](x1, x2) = [0]
                                        
            [mult#2^#](x1, x2, x3) = [0]
                                        
                     [split^#](x1) = [0]
                                        
                   [split#1^#](x1) = [0]
                                        
               [split#2^#](x1, x2) = [0]
                                        
           [split#3^#](x1, x2, x3) = [0]
                                        
               [transpose#2^#](x1) = [0]
                                        
           [transpose#3^#](x1, x2) = [0]
                                        
                [transpose'^#](x1) = [0]
                                        
              [#natmult^#](x1, x2) = [0]
                                        
                     [#pred^#](x1) = [0]
                                        
                     [#succ^#](x1) = [0]
                                        
               [#natadd^#](x1, x2) = [0]
                                        
                         [c_5](x1) = [0]
                                        
                     [c_6](x1, x2) = [0]
                                        
                         [c_8](x1) = [0]
                                        
                               [c] = [0]
                                        
                         [c_1](x1) = [1] x1 + [0]
                                                 
                         [c_2](x1) = [1] x1 + [0]
                                                 
                         [c_3](x1) = [1] x1 + [0]
                                                 
                         [c_4](x1) = [1] x1 + [0]
                                                 
                         [c_5](x1) = [1] x1 + [0]
                                                 
                         [c_6](x1) = [1] x1 + [0]
                                                 
                         [c_7](x1) = [1] x1 + [0]
                                                 
                         [c_8](x1) = [1] x1 + [1]
    
    This order satisfies following ordering constraints
    
                       [matrixMult(@m1, @m2)] =  [1] @m1 + [0]                                          
                                              >= [1] @m1 + [0]                                          
                                              =  [matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))]       
                                                                                                        
                      [matrixMult'(@m1, @m2)] =  [1] @m1 + [0]                                          
                                              >= [1] @m1 + [0]                                          
                                              =  [matrixMult'#1(@m1, @m2)]                              
                                                                                                        
            [matrixMult'#1(::(@l, @ls), @m2)] =  [1] @ls + [1]                                          
                                              >= [1] @ls + [1]                                          
                                              =  [::(lineMult(@l, @m2), matrixMult'(@ls, @m2))]         
                                                                                                        
                  [matrixMult'#1(nil(), @m2)] =  [0]                                                    
                                              >= [0]                                                    
                                              =  [nil()]                                                
                                                                                                        
                     [matrixMult^#(@m1, @m2)] =  [1] @m1 + [0]                                          
                                              >= [1] @m1 + [0]                                          
                                              =  [c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))]
                                                                                                        
                    [matrixMult'^#(@m1, @m2)] =  [1] @m1 + [0]                                          
                                              >= [1] @m1 + [0]                                          
                                              =  [c_1(matrixMult'#1^#(@m1, @m2))]                       
                                                                                                        
          [matrixMult'#1^#(::(@l, @ls), @m2)] =  [1] @ls + [1]                                          
                                              >  [1] @ls + [0]                                          
                                              =  [c_2(matrixMult'^#(@ls, @m2))]                         
                                                                                                        
               [matrixMult3^#(@m1, @m2, @m3)] =  [1] @m1 + [1] @m2 + [1] @m3 + [1]                      
                                              >  [1] @m1 + [0]                                          
                                              =  [c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))]         
                                                                                                        
                [matrixMultList^#(@acc, @mm)] =  [1] @acc + [1]                                         
                                              >= [1] @acc + [1]                                         
                                              =  [c_5(matrixMultList#1^#(@mm, @acc))]                   
                                                                                                        
      [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1] @acc + [1]                                         
                                              >  [1] @acc + [0]                                         
                                              =  [c_6(matrixMult^#(@acc, @m))]                          
                                                                                                        
      [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1] @acc + [1]                                         
                                              >= [1] @acc + [1]                                         
                                              =  [c_7(matrixMultList^#(matrixMult(@acc, @m), @ms))]     
                                                                                                        
                  [matrixMultOld^#(@m1, @m2)] =  [1] @m1 + [1] @m2 + [1]                                
                                              >= [1] @m1 + [1]                                          
                                              =  [c_8(matrixMult'^#(@m1, transpose(@m2)))]              
                                                                                                        
  
  Consider the set of all dependency pairs
  
  DPs:
    { 1: matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2))
    , 2: matrixMult'#1^#(::(@l, @ls), @m2) ->
         c_2(matrixMult'^#(@ls, @m2))
    , 3: matrixMult^#(@m1, @m2) ->
         c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
    , 4: matrixMult3^#(@m1, @m2, @m3) ->
         c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))
    , 5: matrixMultList^#(@acc, @mm) ->
         c_5(matrixMultList#1^#(@mm, @acc))
    , 6: matrixMultList#1^#(::(@m, @ms), @acc) ->
         c_6(matrixMult^#(@acc, @m))
    , 7: matrixMultList#1^#(::(@m, @ms), @acc) ->
         c_7(matrixMultList^#(matrixMult(@acc, @m), @ms))
    , 8: matrixMultOld^#(@m1, @m2) ->
         c_8(matrixMult'^#(@m1, transpose(@m2))) }
  
  Processor 'matrix interpretation of dimension 1' induces the
  complexity certificate YES(?,O(n^1)) on application of dependency
  pairs {2,4,6}. These cover all (indirect) predecessors of
  dependency pairs {1,2,3,4,6,8}, their number of application is
  equally bounded. The dependency pairs are shifted into the
  corresponding weak component(s).
  
  We apply the transformation 'removetails' on the sub-problem:
  
  Weak DPs:
    { matrixMult^#(@m1, @m2) ->
      c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
    , matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2))
    , matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2))
    , matrixMult3^#(@m1, @m2, @m3) ->
      c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))
    , matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_6(matrixMult^#(@acc, @m))
    , matrixMultList#1^#(::(@m, @ms), @acc) ->
      c_7(matrixMultList^#(matrixMult(@acc, @m), @ms))
    , matrixMultOld^#(@m1, @m2) ->
      c_8(matrixMult'^#(@m1, transpose(@m2))) }
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  StartTerms: basic terms
  Strategy: innermost
  
  The following weak DPs constitute a sub-graph of the DG that is
  closed under successors. The DPs are removed.
  
  { matrixMult^#(@m1, @m2) ->
    c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult'^#(@m1, @m2) -> c_1(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_2(matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_4(matrixMult^#(matrixMult(@m1, @m2), @m3))
  , matrixMultList^#(@acc, @mm) -> c_5(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_6(matrixMult^#(@acc, @m))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_7(matrixMultList^#(matrixMult(@acc, @m), @ms))
  , matrixMultOld^#(@m1, @m2) ->
    c_8(matrixMult'^#(@m1, transpose(@m2))) }
  
  
  We apply the transformation 'usablerules' on the sub-problem:
  
  Weak Trs:
    { #abs(#0()) -> #0()
    , #abs(#neg(@x)) -> #pos(@x)
    , #abs(#pos(@x)) -> #pos(@x)
    , #abs(#s(@x)) -> #pos(#s(@x))
    , *(@x, @y) -> #mult(@x, @y)
    , #mult(#0(), #0()) -> #0()
    , #mult(#0(), #neg(@y)) -> #0()
    , #mult(#0(), #pos(@y)) -> #0()
    , #mult(#neg(@x), #0()) -> #0()
    , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
    , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #0()) -> #0()
    , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
    , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
    , +(@x, @y) -> #add(@x, @y)
    , #add(#0(), @y) -> @y
    , #add(#neg(#s(#0())), @y) -> #pred(@y)
    , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
    , #add(#pos(#s(#0())), @y) -> #succ(@y)
    , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
    , attach(@line, @m) -> attach#1(@line, @m)
    , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
    , attach#1(nil(), @m) -> nil()
    , attach#2(::(@l, @ls), @x, @xs) ->
      ::(::(@x, @l), attach(@xs, @ls))
    , attach#2(nil(), @x, @xs) -> nil()
    , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
    , lineMult#1(::(@x, @xs), @l) ->
      ::(mult(@l, @x), lineMult(@l, @xs))
    , lineMult#1(nil(), @l) -> nil()
    , mult(@l1, @l2) -> mult#1(@l1, @l2)
    , makeBase(@m) -> makeBase#1(@m)
    , makeBase#1(::(@l, @m')) -> mkBase(@l)
    , makeBase#1(nil()) -> nil()
    , mkBase(@m) -> mkBase#1(@m)
    , matrixMult(@m1, @m2) ->
      matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
    , transAcc(@m, @base) -> transAcc#1(@m, @base)
    , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
    , matrixMult'#1(::(@l, @ls), @m2) ->
      ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
    , matrixMult'#1(nil(), @m2) -> nil()
    , transpose(@m) -> transpose#1(@m, @m)
    , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
    , mkBase#1(nil()) -> nil()
    , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
    , mult#1(nil(), @l2) -> #abs(#0())
    , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
    , mult#2(nil(), @x, @xs) -> #abs(#0())
    , split(@m) -> split#1(@m)
    , split#1(::(@l, @ls)) -> split#2(@l, @ls)
    , split#1(nil()) -> tuple#2(nil(), nil())
    , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
    , split#2(nil(), @ls) -> tuple#2(nil(), nil())
    , split#3(tuple#2(@ys, @m'), @x, @xs) ->
      tuple#2(::(@x, @ys), ::(@xs, @m'))
    , transAcc#1(::(@l, @m'), @base) ->
      attach(@l, transAcc(@m', @base))
    , transAcc#1(nil(), @base) -> @base
    , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
    , transpose#1(nil(), @m) -> nil()
    , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
    , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
    , transpose#3(nil(), @l) -> nil()
    , #pred(#0()) -> #neg(#s(#0()))
    , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
    , #pred(#pos(#s(#0()))) -> #0()
    , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
    , #succ(#0()) -> #pos(#s(#0()))
    , #succ(#neg(#s(#0()))) -> #0()
    , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
    , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
    , #natmult(#0(), @y) -> #0()
    , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
    , #natadd(#0(), @y) -> @y
    , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
  StartTerms: basic terms
  Strategy: innermost
  
  No rule is usable, rules are removed from the input problem.
  
  
  We are left with following problem, upon which TcT provides the
  certificate YES(O(1),O(1)).
  
  Rules: Empty
  Obligation:
    innermost runtime complexity
  Answer:
    YES(O(1),O(1))
  
  Empty rules are trivially bounded

We return to the main proof.

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^1))

We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.

DPs:
  { 5: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys))
  , 10: matrixMult3^#(@m1, @m2, @m3) ->
        matrixMult^#(matrixMult(@m1, @m2), @m3)
  , 12: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMult^#(@acc, @m) }
Trs:
  { attach#2(nil(), @x, @xs) -> nil()
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , transpose#1(nil(), @m) -> nil()
  , transpose#3(nil(), @l) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_7) = {1}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA) and not(IDA(1)).
  
                            [#0] = [0]
                                   [0]
                                      
                      [#abs](x1) = [0 0] x1 + [0]
                                   [1 0]      [0]
                                                 
                      [#neg](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [#pos](x1) = [0 1] x1 + [0]
                                   [1 0]      [0]
                                                 
                        [#s](x1) = [0 1] x1 + [0]
                                   [1 0]      [0]
                                                 
                     [*](x1, x2) = [0]
                                   [0]
                                      
                 [#mult](x1, x2) = [0]
                                   [0]
                                      
                     [+](x1, x2) = [0]
                                   [0]
                                      
                  [#add](x1, x2) = [1 0] x2 + [0]
                                   [1 1]      [0]
                                                 
                [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
              [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
                    [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
          [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1]
                                   [0 1]      [0 0]      [0 0]      [0]
                                                                       
                           [nil] = [0]
                                   [0]
                                      
              [lineMult](x1, x2) = [0 1] x2 + [1]
                                   [0 1]      [1]
                                                 
            [lineMult#1](x1, x2) = [1 1] x1 + [0]
                                   [0 1]      [1]
                                                 
                  [mult](x1, x2) = [0 0] x2 + [1]
                                   [1 0]      [0]
                                                 
                  [makeBase](x1) = [0 1] x1 + [0]
                                   [1 0]      [0]
                                                 
                [makeBase#1](x1) = [0 1] x1 + [0]
                                   [1 0]      [0]
                                                 
                    [mkBase](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
            [matrixMult](x1, x2) = [0 1] x1 + [0]
                                   [0 1]      [0]
                                                 
              [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [1 1]      [0]
                                                            
           [matrixMult'](x1, x2) = [0 1] x1 + [0]
                                   [0 1]      [0]
                                                 
         [matrixMult'#1](x1, x2) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                 [transpose](x1) = [1 1] x1 + [1]
                                   [1 0]      [0]
                                                 
                  [mkBase#1](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                [mult#1](x1, x2) = [1 1] x1 + [0]
                                   [0 1]      [0]
                                                 
            [mult#2](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [0]
                                   [1 0]      [1 0]      [0]
                                                            
                     [split](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                   [split#1](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
               [split#2](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
               [tuple#2](x1, x2) = [1 0] x1 + [1 1] x2 + [0]
                                   [0 1]      [0 0]      [0]
                                                            
           [split#3](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1]
                                   [0 1]      [0 0]      [0 0]      [1]
                                                                       
            [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [1 1]      [0]
                                                            
           [transpose#1](x1, x2) = [1 1] x2 + [1]
                                   [1 0]      [0]
                                                 
               [transpose#2](x1) = [1 1] x1 + [1]
                                   [1 0]      [0]
                                                 
           [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [1]
                                   [1 1]      [0 0]      [0]
                                                            
                     [#pred](x1) = [0]
                                   [0]
                                      
                     [#succ](x1) = [0]
                                   [0]
                                      
              [#natmult](x1, x2) = [0]
                                   [0]
                                      
               [#natadd](x1, x2) = [0]
                                   [0]
                                      
                    [#abs^#](x1) = [0]
                                   [0]
                                      
                   [*^#](x1, x2) = [0]
                                   [0]
                                      
               [#mult^#](x1, x2) = [0]
                                   [0]
                                      
                   [+^#](x1, x2) = [0]
                                   [0]
                                      
                [#add^#](x1, x2) = [0]
                                   [0]
                                      
              [attach^#](x1, x2) = [0]
                                   [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                   [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
            [lineMult^#](x1, x2) = [1 0] x2 + [0]
                                   [0 0]      [0]
                                                 
          [lineMult#1^#](x1, x2) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                [mult^#](x1, x2) = [0 1] x2 + [0]
                                   [0 0]      [0]
                                                 
              [mult#1^#](x1, x2) = [0 1] x2 + [0]
                                   [0 0]      [0]
                                                 
                [makeBase^#](x1) = [0]
                                   [0]
                                      
              [makeBase#1^#](x1) = [0]
                                   [0]
                                      
                  [mkBase^#](x1) = [0]
                                   [0]
                                      
                [mkBase#1^#](x1) = [0]
                                   [0]
                                      
          [matrixMult^#](x1, x2) = [1 1] x2 + [0]
                                   [0 0]      [0]
                                                 
         [matrixMult'^#](x1, x2) = [1 0] x2 + [0]
                                   [0 0]      [0]
                                                 
            [transAcc^#](x1, x2) = [0]
                                   [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMult'#1^#](x1, x2) = [1 0] x2 + [0]
                                   [0 0]      [0]
                                                 
     [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1]
                                   [1 1]      [1 1]      [1 1]      [1]
                                                                       
      [matrixMultList^#](x1, x2) = [1 0] x2 + [1]
                                   [0 0]      [1]
                                                 
    [matrixMultList#1^#](x1, x2) = [1 0] x1 + [1]
                                   [0 0]      [1]
                                                 
       [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1]
                                   [1 1]      [1 1]      [1]
                                                            
               [transpose^#](x1) = [0]
                                   [0]
                                      
         [transpose#1^#](x1, x2) = [0]
                                   [0]
                                      
          [mult#2^#](x1, x2, x3) = [0 1] x1 + [0]
                                   [0 1]      [0]
                                                 
                   [split^#](x1) = [0]
                                   [0]
                                      
                 [split#1^#](x1) = [0]
                                   [0]
                                      
             [split#2^#](x1, x2) = [0]
                                   [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                   [0]
                                      
             [transpose#2^#](x1) = [0]
                                   [0]
                                      
         [transpose#3^#](x1, x2) = [0]
                                   [0]
                                      
              [transpose'^#](x1) = [0]
                                   [0]
                                      
            [#natmult^#](x1, x2) = [0]
                                   [0]
                                      
                   [#pred^#](x1) = [0]
                                   [0]
                                      
                   [#succ^#](x1) = [0]
                                   [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                   [0]
                                      
                       [c_1](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_2](x1, x2) = [1 1] x1 + [1 1] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_3](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_4](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_7](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
  
  This order satisfies following ordering constraints
  
                        [attach(@line, @m)] =  [1 1] @line + [1 0] @m + [0]                      
                                               [0 0]         [0 1]      [0]                      
                                            >= [1 1] @line + [1 0] @m + [0]                      
                                               [0 0]         [0 1]      [0]                      
                                            =  [attach#1(@line, @m)]                             
                                                                                                 
                [attach#1(::(@x, @xs), @m)] =  [1 0] @m + [1 1] @x + [1 1] @xs + [1]             
                                               [0 1]      [0 0]      [0 0]       [0]             
                                            >= [1 0] @m + [1 1] @x + [1 1] @xs + [1]             
                                               [0 1]      [0 0]      [0 0]       [0]             
                                            =  [attach#2(@m, @x, @xs)]                           
                                                                                                 
                      [attach#1(nil(), @m)] =  [1 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            >= [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
           [attach#2(::(@l, @ls), @x, @xs)] =  [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] 
                                               [0 0]      [0 1]       [0 0]      [0 0]       [1] 
                                            >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1] 
                                               [0 0]      [0 1]       [0 0]      [0 0]       [1] 
                                            =  [::(::(@x, @l), attach(@xs, @ls))]                
                                                                                                 
                 [attach#2(nil(), @x, @xs)] =  [1 1] @x + [1 1] @xs + [1]                        
                                               [0 0]      [0 0]       [0]                        
                                            >  [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                             [makeBase(@m)] =  [0 1] @m + [0]                                    
                                               [1 0]      [0]                                    
                                            >= [0 1] @m + [0]                                    
                                               [1 0]      [0]                                    
                                            =  [makeBase#1(@m)]                                  
                                                                                                 
                  [makeBase#1(::(@l, @m'))] =  [0 0] @l + [0 1] @m' + [1]                        
                                               [1 1]      [1 0]       [0]                        
                                            >  [0 0] @l + [0]                                    
                                               [0 1]      [0]                                    
                                            =  [mkBase(@l)]                                      
                                                                                                 
                        [makeBase#1(nil())] =  [0]                                               
                                               [0]                                               
                                            >= [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                               [mkBase(@m)] =  [0 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            >= [0 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            =  [mkBase#1(@m)]                                    
                                                                                                 
                      [transAcc(@m, @base)] =  [1 0] @base + [1 0] @m + [0]                      
                                               [1 1]         [0 0]      [0]                      
                                            >= [1 0] @base + [1 0] @m + [0]                      
                                               [1 1]         [0 0]      [0]                      
                                            =  [transAcc#1(@m, @base)]                           
                                                                                                 
                            [transpose(@m)] =  [1 1] @m + [1]                                    
                                               [1 0]      [0]                                    
                                            >= [1 1] @m + [1]                                    
                                               [1 0]      [0]                                    
                                            =  [transpose#1(@m, @m)]                             
                                                                                                 
                    [mkBase#1(::(@l, @m'))] =  [0 0] @m' + [0]                                   
                                               [0 1]       [1]                                   
                                            >= [0 0] @m' + [0]                                   
                                               [0 1]       [1]                                   
                                            =  [::(nil(), mkBase(@m'))]                          
                                                                                                 
                          [mkBase#1(nil())] =  [0]                                               
                                               [0]                                               
                                            >= [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                                [split(@m)] =  [1 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            >= [1 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            =  [split#1(@m)]                                     
                                                                                                 
                     [split#1(::(@l, @ls))] =  [1 1] @l + [1 0] @ls + [0]                        
                                               [0 0]      [0 1]       [1]                        
                                            >= [1 1] @l + [1 0] @ls + [0]                        
                                               [0 0]      [0 1]       [1]                        
                                            =  [split#2(@l, @ls)]                                
                                                                                                 
                           [split#1(nil())] =  [0]                                               
                                               [0]                                               
                                            >= [0]                                               
                                               [0]                                               
                                            =  [tuple#2(nil(), nil())]                           
                                                                                                 
                [split#2(::(@x, @xs), @ls)] =  [1 0] @ls + [1 1] @x + [1 1] @xs + [1]            
                                               [0 1]       [0 0]      [0 0]       [1]            
                                            >= [1 0] @ls + [1 1] @x + [1 1] @xs + [1]            
                                               [0 1]       [0 0]      [0 0]       [1]            
                                            =  [split#3(split(@ls), @x, @xs)]                    
                                                                                                 
                      [split#2(nil(), @ls)] =  [1 0] @ls + [0]                                   
                                               [0 1]       [1]                                   
                                            >= [0]                                               
                                               [0]                                               
                                            =  [tuple#2(nil(), nil())]                           
                                                                                                 
      [split#3(tuple#2(@ys, @m'), @x, @xs)] =  [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1]
                                               [0 0]       [0 0]      [0 0]       [0 1]       [1]
                                            >= [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1]
                                               [0 0]       [0 0]      [0 0]       [0 1]       [1]
                                            =  [tuple#2(::(@x, @ys), ::(@xs, @m'))]              
                                                                                                 
           [transAcc#1(::(@l, @m'), @base)] =  [1 0] @base + [1 1] @l + [1 0] @m' + [0]          
                                               [1 1]         [0 0]      [0 0]       [0]          
                                            >= [1 0] @base + [1 1] @l + [1 0] @m' + [0]          
                                               [1 1]         [0 0]      [0 0]       [0]          
                                            =  [attach(@l, transAcc(@m', @base))]                
                                                                                                 
                 [transAcc#1(nil(), @base)] =  [1 0] @base + [0]                                 
                                               [1 1]         [0]                                 
                                            >= [1 0] @base + [0]                                 
                                               [0 1]         [0]                                 
                                            =  [@base]                                           
                                                                                                 
           [transpose#1(::(@xs, @xss), @m)] =  [1 1] @m + [1]                                    
                                               [1 0]      [0]                                    
                                            >= [1 1] @m + [1]                                    
                                               [1 0]      [0]                                    
                                            =  [transpose#2(split(@m))]                          
                                                                                                 
                   [transpose#1(nil(), @m)] =  [1 1] @m + [1]                                    
                                               [1 0]      [0]                                    
                                            >  [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
            [transpose#2(tuple#2(@l, @m'))] =  [1 1] @l + [1 1] @m' + [1]                        
                                               [1 0]      [1 1]       [0]                        
                                            >= [1 1] @l + [1 1] @m' + [1]                        
                                               [0 0]      [1 1]       [0]                        
                                            =  [transpose#3(@m', @l)]                            
                                                                                                 
             [transpose#3(::(@y, @ys), @l)] =  [1 1] @l + [1 1] @y + [1 1] @ys + [2]             
                                               [0 0]      [1 1]      [1 1]       [1]             
                                            >= [1 1] @l + [1 1] @y + [1 1] @ys + [2]             
                                               [0 0]      [1 1]      [1 0]       [1]             
                                            =  [::(@l, transpose(::(@y, @ys)))]                  
                                                                                                 
                   [transpose#3(nil(), @l)] =  [1 1] @l + [1]                                    
                                               [0 0]      [0]                                    
                                            >  [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                      [lineMult^#(@l, @m2)] =  [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [c_1(lineMult#1^#(@m2, @l))]                      
                                                                                                 
            [lineMult#1^#(::(@x, @xs), @l)] =  [1 1] @x + [1 0] @xs + [0]                        
                                               [0 0]      [0 0]       [0]                        
                                            >= [0 1] @x + [1 0] @xs + [0]                        
                                               [0 0]      [0 0]       [0]                        
                                            =  [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))]        
                                                                                                 
                         [mult^#(@l1, @l2)] =  [0 1] @l2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [0 1] @l2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [c_3(mult#1^#(@l1, @l2))]                         
                                                                                                 
               [mult#1^#(::(@x, @xs), @l2)] =  [0 1] @l2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [0 1] @l2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [c_4(mult#2^#(@l2, @x, @xs))]                     
                                                                                                 
                   [matrixMult^#(@m1, @m2)] =  [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))]
                                                                                                 
                  [matrixMult'^#(@m1, @m2)] =  [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'#1^#(@m1, @m2)]                       
                                                                                                 
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [lineMult^#(@l, @m2)]                             
                                                                                                 
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 0] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'^#(@ls, @m2)]                         
                                                                                                 
             [matrixMult3^#(@m1, @m2, @m3)] =  [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1]           
                                               [1 1]       [1 1]       [1 1]       [1]           
                                            >  [1 1] @m3 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult^#(matrixMult(@m1, @m2), @m3)]         
                                                                                                 
              [matrixMultList^#(@acc, @mm)] =  [1 0] @mm + [1]                                   
                                               [0 0]       [1]                                   
                                            >= [1 0] @mm + [1]                                   
                                               [0 0]       [1]                                   
                                            =  [matrixMultList#1^#(@mm, @acc)]                   
                                                                                                 
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1 1] @m + [1 0] @ms + [1]                        
                                               [0 0]      [0 0]       [1]                        
                                            >  [1 1] @m + [0]                                    
                                               [0 0]      [0]                                    
                                            =  [matrixMult^#(@acc, @m)]                          
                                                                                                 
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1 1] @m + [1 0] @ms + [1]                        
                                               [0 0]      [0 0]       [1]                        
                                            >= [1 0] @ms + [1]                                   
                                               [0 0]       [1]                                   
                                            =  [matrixMultList^#(matrixMult(@acc, @m), @ms)]     
                                                                                                 
                [matrixMultOld^#(@m1, @m2)] =  [1 0] @m1 + [1 1] @m2 + [1]                       
                                               [1 1]       [1 1]       [1]                       
                                            >= [1 1] @m2 + [1]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'^#(@m1, transpose(@m2))]              
                                                                                                 
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0 1] @ys + [1]                                   
                                               [0 1]       [1]                                   
                                            >  [0 1] @ys + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [c_7(mult^#(@xs, @ys))]                           
                                                                                                 

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) ->
       c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , 5: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys))
  , 6: matrixMult^#(@m1, @m2) ->
       matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , 7: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
  , 8: matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
  , 9: matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
  , 10: matrixMult3^#(@m1, @m2, @m3) ->
        matrixMult^#(matrixMult(@m1, @m2), @m3)
  , 11: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , 12: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMult^#(@acc, @m)
  , 13: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMultList^#(matrixMult(@acc, @m), @ms)
  , 14: matrixMultOld^#(@m1, @m2) ->
        matrixMult'^#(@m1, transpose(@m2)) }

Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {5,10,12}. These cover all (indirect) predecessors of
dependency pairs {5,6,10,12,14}, their number of application is
equally bounded. The dependency pairs are shifted into the
corresponding weak component(s).


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^1))

We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.

DPs:
  { 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 5: matrixMult^#(@m1, @m2) ->
       matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , 11: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMult^#(@acc, @m)
  , 12: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMultList^#(matrixMult(@acc, @m), @ms) }
Trs:
  { attach#2(nil(), @x, @xs) -> nil()
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , transpose#1(nil(), @m) -> nil()
  , transpose#3(nil(), @l) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1, 2}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_7) = {1}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA) and not(IDA(1)).
  
                            [#0] = [0]
                                   [0]
                                      
                      [#abs](x1) = [0]
                                   [0]
                                      
                      [#neg](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                      [#pos](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                        [#s](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                     [*](x1, x2) = [0]
                                   [0]
                                      
                 [#mult](x1, x2) = [0]
                                   [0]
                                      
                     [+](x1, x2) = [0]
                                   [0]
                                      
                  [#add](x1, x2) = [0]
                                   [0]
                                      
                [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
              [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
                    [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [2]
                                                            
          [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [2]
                                   [0 1]      [0 0]      [0 0]      [0]
                                                                       
                           [nil] = [0]
                                   [0]
                                      
              [lineMult](x1, x2) = [0 0] x2 + [0]
                                   [0 1]      [0]
                                                 
            [lineMult#1](x1, x2) = [0 0] x1 + [0 0] x2 + [0]
                                   [0 1]      [2 2]      [0]
                                                            
                  [mult](x1, x2) = [0]
                                   [2]
                                      
                  [makeBase](x1) = [0 0] x1 + [0]
                                   [1 0]      [1]
                                                 
                [makeBase#1](x1) = [0 0] x1 + [0]
                                   [1 0]      [1]
                                                 
                    [mkBase](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
            [matrixMult](x1, x2) = [0 0] x1 + [2 2] x2 + [2]
                                   [0 1]      [0 0]      [0]
                                                            
              [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 1]      [0 1]      [0]
                                                            
           [matrixMult'](x1, x2) = [0 0] x1 + [0 2] x2 + [0]
                                   [0 1]      [0 0]      [0]
                                                            
         [matrixMult'#1](x1, x2) = [0 0] x1 + [2 2] x2 + [0]
                                   [0 1]      [2 2]      [0]
                                                            
                 [transpose](x1) = [1 1] x1 + [2]
                                   [1 1]      [0]
                                                 
                  [mkBase#1](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                [mult#1](x1, x2) = [2 0] x2 + [0]
                                   [2 2]      [0]
                                                 
            [mult#2](x1, x2, x3) = [0 0] x2 + [0]
                                   [0 2]      [0]
                                                 
                     [split](x1) = [0 1] x1 + [0]
                                   [1 0]      [2]
                                                 
                   [split#1](x1) = [0 1] x1 + [0]
                                   [1 0]      [2]
                                                 
               [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [2]
                                   [1 1]      [1 0]      [2]
                                                            
               [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0]
                                   [1 0]      [1 1]      [2]
                                                            
           [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [2]
                                   [0 1]      [1 1]      [1 1]      [2]
                                                                       
            [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 1]      [0 1]      [0]
                                                            
           [transpose#1](x1, x2) = [0 0] x1 + [1 1] x2 + [2]
                                   [0 1]      [1 0]      [0]
                                                            
               [transpose#2](x1) = [1 1] x1 + [0]
                                   [0 1]      [0]
                                                 
           [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [2]
                                   [1 1]      [1 0]      [2]
                                                            
                     [#pred](x1) = [0]
                                   [0]
                                      
                     [#succ](x1) = [0]
                                   [0]
                                      
              [#natmult](x1, x2) = [0]
                                   [0]
                                      
               [#natadd](x1, x2) = [0]
                                   [0]
                                      
                    [#abs^#](x1) = [0]
                                   [0]
                                      
                   [*^#](x1, x2) = [0]
                                   [0]
                                      
               [#mult^#](x1, x2) = [0]
                                   [0]
                                      
                   [+^#](x1, x2) = [0]
                                   [0]
                                      
                [#add^#](x1, x2) = [0]
                                   [0]
                                      
              [attach^#](x1, x2) = [0]
                                   [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                   [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
            [lineMult^#](x1, x2) = [1 1] x2 + [0]
                                   [0 0]      [0]
                                                 
          [lineMult#1^#](x1, x2) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                [mult^#](x1, x2) = [0 1] x2 + [2]
                                   [1 0]      [2]
                                                 
              [mult#1^#](x1, x2) = [0 1] x2 + [0]
                                   [0 0]      [1]
                                                 
                [makeBase^#](x1) = [0]
                                   [0]
                                      
              [makeBase#1^#](x1) = [0]
                                   [0]
                                      
                  [mkBase^#](x1) = [0]
                                   [0]
                                      
                [mkBase#1^#](x1) = [0]
                                   [0]
                                      
          [matrixMult^#](x1, x2) = [2 2] x2 + [2]
                                   [0 0]      [0]
                                                 
         [matrixMult'^#](x1, x2) = [1 1] x2 + [0]
                                   [0 0]      [0]
                                                 
            [transAcc^#](x1, x2) = [0]
                                   [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMult'#1^#](x1, x2) = [1 1] x2 + [0]
                                   [0 0]      [0]
                                                 
     [matrixMult3^#](x1, x2, x3) = [2 0] x1 + [1 0] x2 + [2 2] x3 + [2]
                                   [2 2]      [1 1]      [2 2]      [2]
                                                                       
      [matrixMultList^#](x1, x2) = [2 2] x2 + [0]
                                   [0 0]      [0]
                                                 
    [matrixMultList#1^#](x1, x2) = [2 2] x1 + [0]
                                   [0 0]      [0]
                                                 
       [matrixMultOld^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2]
                                   [2 2]      [2 2]      [2]
                                                            
               [transpose^#](x1) = [0]
                                   [0]
                                      
         [transpose#1^#](x1, x2) = [0]
                                   [0]
                                      
          [mult#2^#](x1, x2, x3) = [0 1] x1 + [0]
                                   [0 0]      [1]
                                                 
                   [split^#](x1) = [0]
                                   [0]
                                      
                 [split#1^#](x1) = [0]
                                   [0]
                                      
             [split#2^#](x1, x2) = [0]
                                   [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                   [0]
                                      
             [transpose#2^#](x1) = [0]
                                   [0]
                                      
         [transpose#3^#](x1, x2) = [0]
                                   [0]
                                      
              [transpose'^#](x1) = [0]
                                   [0]
                                      
            [#natmult^#](x1, x2) = [0]
                                   [0]
                                      
                   [#pred^#](x1) = [0]
                                   [0]
                                      
                   [#succ^#](x1) = [0]
                                   [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                   [0]
                                      
                       [c_1](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                   [c_2](x1, x2) = [1 0] x1 + [1 1] x2 + [0]
                                   [0 0]      [0 0]      [0]
                                                            
                       [c_3](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_4](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_7](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
  
  This order satisfies following ordering constraints
  
                        [attach(@line, @m)] =  [1 1] @line + [1 0] @m + [0]                      
                                               [0 0]         [0 1]      [0]                      
                                            >= [1 1] @line + [1 0] @m + [0]                      
                                               [0 0]         [0 1]      [0]                      
                                            =  [attach#1(@line, @m)]                             
                                                                                                 
                [attach#1(::(@x, @xs), @m)] =  [1 0] @m + [1 1] @x + [1 1] @xs + [2]             
                                               [0 1]      [0 0]      [0 0]       [0]             
                                            >= [1 0] @m + [1 1] @x + [1 1] @xs + [2]             
                                               [0 1]      [0 0]      [0 0]       [0]             
                                            =  [attach#2(@m, @x, @xs)]                           
                                                                                                 
                      [attach#1(nil(), @m)] =  [1 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            >= [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
           [attach#2(::(@l, @ls), @x, @xs)] =  [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [2] 
                                               [0 0]      [0 1]       [0 0]      [0 0]       [2] 
                                            >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [2] 
                                               [0 0]      [0 1]       [0 0]      [0 0]       [2] 
                                            =  [::(::(@x, @l), attach(@xs, @ls))]                
                                                                                                 
                 [attach#2(nil(), @x, @xs)] =  [1 1] @x + [1 1] @xs + [2]                        
                                               [0 0]      [0 0]       [0]                        
                                            >  [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                             [makeBase(@m)] =  [0 0] @m + [0]                                    
                                               [1 0]      [1]                                    
                                            >= [0 0] @m + [0]                                    
                                               [1 0]      [1]                                    
                                            =  [makeBase#1(@m)]                                  
                                                                                                 
                  [makeBase#1(::(@l, @m'))] =  [0 0] @l + [0 0] @m' + [0]                        
                                               [1 1]      [1 0]       [1]                        
                                            >= [0 0] @l + [0]                                    
                                               [0 1]      [0]                                    
                                            =  [mkBase(@l)]                                      
                                                                                                 
                        [makeBase#1(nil())] =  [0]                                               
                                               [1]                                               
                                            >= [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                               [mkBase(@m)] =  [0 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            >= [0 0] @m + [0]                                    
                                               [0 1]      [0]                                    
                                            =  [mkBase#1(@m)]                                    
                                                                                                 
                      [transAcc(@m, @base)] =  [1 0] @base + [1 0] @m + [0]                      
                                               [0 1]         [0 1]      [0]                      
                                            >= [1 0] @base + [1 0] @m + [0]                      
                                               [0 1]         [0 1]      [0]                      
                                            =  [transAcc#1(@m, @base)]                           
                                                                                                 
                            [transpose(@m)] =  [1 1] @m + [2]                                    
                                               [1 1]      [0]                                    
                                            >= [1 1] @m + [2]                                    
                                               [1 1]      [0]                                    
                                            =  [transpose#1(@m, @m)]                             
                                                                                                 
                    [mkBase#1(::(@l, @m'))] =  [0 0] @m' + [0]                                   
                                               [0 1]       [2]                                   
                                            >= [0 0] @m' + [0]                                   
                                               [0 1]       [2]                                   
                                            =  [::(nil(), mkBase(@m'))]                          
                                                                                                 
                          [mkBase#1(nil())] =  [0]                                               
                                               [0]                                               
                                            >= [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                                [split(@m)] =  [0 1] @m + [0]                                    
                                               [1 0]      [2]                                    
                                            >= [0 1] @m + [0]                                    
                                               [1 0]      [2]                                    
                                            =  [split#1(@m)]                                     
                                                                                                 
                     [split#1(::(@l, @ls))] =  [0 0] @l + [0 1] @ls + [2]                        
                                               [1 1]      [1 0]       [2]                        
                                            >= [0 0] @l + [0 1] @ls + [2]                        
                                               [1 1]      [1 0]       [2]                        
                                            =  [split#2(@l, @ls)]                                
                                                                                                 
                           [split#1(nil())] =  [0]                                               
                                               [2]                                               
                                            >= [0]                                               
                                               [2]                                               
                                            =  [tuple#2(nil(), nil())]                           
                                                                                                 
                [split#2(::(@x, @xs), @ls)] =  [0 1] @ls + [0 0] @x + [0 0] @xs + [2]            
                                               [1 0]       [1 1]      [1 1]       [4]            
                                            >= [0 1] @ls + [0 0] @x + [0 0] @xs + [2]            
                                               [1 0]       [1 1]      [1 1]       [4]            
                                            =  [split#3(split(@ls), @x, @xs)]                    
                                                                                                 
                      [split#2(nil(), @ls)] =  [0 1] @ls + [2]                                   
                                               [1 0]       [2]                                   
                                            >  [0]                                               
                                               [2]                                               
                                            =  [tuple#2(nil(), nil())]                           
                                                                                                 
      [split#3(tuple#2(@ys, @m'), @x, @xs)] =  [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [2]
                                               [1 1]       [1 1]      [1 1]       [1 0]       [4]
                                            >= [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [2]
                                               [1 1]       [1 1]      [1 1]       [1 0]       [4]
                                            =  [tuple#2(::(@x, @ys), ::(@xs, @m'))]              
                                                                                                 
           [transAcc#1(::(@l, @m'), @base)] =  [1 0] @base + [1 1] @l + [1 0] @m' + [0]          
                                               [0 1]         [0 0]      [0 1]       [2]          
                                            >= [1 0] @base + [1 1] @l + [1 0] @m' + [0]          
                                               [0 1]         [0 0]      [0 1]       [0]          
                                            =  [attach(@l, transAcc(@m', @base))]                
                                                                                                 
                 [transAcc#1(nil(), @base)] =  [1 0] @base + [0]                                 
                                               [0 1]         [0]                                 
                                            >= [1 0] @base + [0]                                 
                                               [0 1]         [0]                                 
                                            =  [@base]                                           
                                                                                                 
           [transpose#1(::(@xs, @xss), @m)] =  [1 1] @m + [0 0] @xss + [2]                       
                                               [1 0]      [0 1]        [2]                       
                                            >= [1 1] @m + [2]                                    
                                               [1 0]      [2]                                    
                                            =  [transpose#2(split(@m))]                          
                                                                                                 
                   [transpose#1(nil(), @m)] =  [1 1] @m + [2]                                    
                                               [1 0]      [0]                                    
                                            >  [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
            [transpose#2(tuple#2(@l, @m'))] =  [1 1] @l + [1 1] @m' + [2]                        
                                               [1 0]      [1 1]       [2]                        
                                            >= [1 1] @l + [1 1] @m' + [2]                        
                                               [1 0]      [1 1]       [2]                        
                                            =  [transpose#3(@m', @l)]                            
                                                                                                 
             [transpose#3(::(@y, @ys), @l)] =  [1 1] @l + [1 1] @y + [1 1] @ys + [4]             
                                               [1 0]      [1 1]      [1 1]       [4]             
                                            >= [1 1] @l + [1 1] @y + [1 1] @ys + [4]             
                                               [0 0]      [1 1]      [1 1]       [4]             
                                            =  [::(@l, transpose(::(@y, @ys)))]                  
                                                                                                 
                   [transpose#3(nil(), @l)] =  [1 1] @l + [2]                                    
                                               [1 0]      [2]                                    
                                            >  [0]                                               
                                               [0]                                               
                                            =  [nil()]                                           
                                                                                                 
                      [lineMult^#(@l, @m2)] =  [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [c_1(lineMult#1^#(@m2, @l))]                      
                                                                                                 
            [lineMult#1^#(::(@x, @xs), @l)] =  [1 1] @x + [1 1] @xs + [2]                        
                                               [0 0]      [0 0]       [0]                        
                                            >= [0 1] @x + [1 1] @xs + [2]                        
                                               [0 0]      [0 0]       [0]                        
                                            =  [c_2(mult^#(@l, @x), lineMult^#(@l, @xs))]        
                                                                                                 
                         [mult^#(@l1, @l2)] =  [0 1] @l2 + [2]                                   
                                               [1 0]       [2]                                   
                                            >  [0 1] @l2 + [1]                                   
                                               [0 0]       [0]                                   
                                            =  [c_3(mult#1^#(@l1, @l2))]                         
                                                                                                 
               [mult#1^#(::(@x, @xs), @l2)] =  [0 1] @l2 + [0]                                   
                                               [0 0]       [1]                                   
                                            >= [0 1] @l2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [c_4(mult#2^#(@l2, @x, @xs))]                     
                                                                                                 
                   [matrixMult^#(@m1, @m2)] =  [2 2] @m2 + [2]                                   
                                               [0 0]       [0]                                   
                                            >  [2 1] @m2 + [1]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))]
                                                                                                 
                  [matrixMult'^#(@m1, @m2)] =  [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'#1^#(@m1, @m2)]                       
                                                                                                 
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [lineMult^#(@l, @m2)]                             
                                                                                                 
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [1 1] @m2 + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'^#(@ls, @m2)]                         
                                                                                                 
             [matrixMult3^#(@m1, @m2, @m3)] =  [2 0] @m1 + [1 0] @m2 + [2 2] @m3 + [2]           
                                               [2 2]       [1 1]       [2 2]       [2]           
                                            >= [2 2] @m3 + [2]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult^#(matrixMult(@m1, @m2), @m3)]         
                                                                                                 
              [matrixMultList^#(@acc, @mm)] =  [2 2] @mm + [0]                                   
                                               [0 0]       [0]                                   
                                            >= [2 2] @mm + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMultList#1^#(@mm, @acc)]                   
                                                                                                 
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [2 2] @m + [2 2] @ms + [4]                        
                                               [0 0]      [0 0]       [0]                        
                                            >  [2 2] @m + [2]                                    
                                               [0 0]      [0]                                    
                                            =  [matrixMult^#(@acc, @m)]                          
                                                                                                 
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [2 2] @m + [2 2] @ms + [4]                        
                                               [0 0]      [0 0]       [0]                        
                                            >  [2 2] @ms + [0]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMultList^#(matrixMult(@acc, @m), @ms)]     
                                                                                                 
                [matrixMultOld^#(@m1, @m2)] =  [2 2] @m1 + [2 2] @m2 + [2]                       
                                               [2 2]       [2 2]       [2]                       
                                            >= [2 2] @m2 + [2]                                   
                                               [0 0]       [0]                                   
                                            =  [matrixMult'^#(@m1, transpose(@m2))]              
                                                                                                 
           [mult#2^#(::(@y, @ys), @x, @xs)] =  [0 1] @ys + [2]                                   
                                               [0 0]       [1]                                   
                                            >= [0 1] @ys + [2]                                   
                                               [0 0]       [0]                                   
                                            =  [c_7(mult^#(@xs, @ys))]                           
                                                                                                 

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) ->
       c_2(mult^#(@l, @x), lineMult^#(@l, @xs))
  , 3: mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , 4: mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , 5: matrixMult^#(@m1, @m2) ->
       matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , 6: matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
  , 7: matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
  , 8: matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
  , 9: matrixMult3^#(@m1, @m2, @m3) ->
       matrixMult^#(matrixMult(@m1, @m2), @m3)
  , 10: matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , 11: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMult^#(@acc, @m)
  , 12: matrixMultList#1^#(::(@m, @ms), @acc) ->
        matrixMultList^#(matrixMult(@acc, @m), @ms)
  , 13: matrixMultOld^#(@m1, @m2) ->
        matrixMult'^#(@m1, transpose(@m2))
  , 14: mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }

Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {3,5,11,12}. These cover all (indirect) predecessors of
dependency pairs {3,4,5,9,10,11,12,13,14}, their number of
application is equally bounded. The dependency pairs are shifted
into the corresponding weak component(s).

We apply the transformation 'removetails' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) }
Weak DPs:
  { mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
  , mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
  , matrixMult^#(@m1, @m2) ->
    matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2))
  , mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ mult^#(@l1, @l2) -> c_3(mult#1^#(@l1, @l2))
, mult#1^#(::(@x, @xs), @l2) -> c_4(mult#2^#(@l2, @x, @xs))
, mult#2^#(::(@y, @ys), @x, @xs) -> c_7(mult^#(@xs, @ys)) }

We apply the transformation 'simpDPRHS' on the sub-problem:

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2)))
  , matrixMult'^#(@m1, @m2) -> matrixMult'#1^#(@m1, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> lineMult^#(@l, @m2)
  , matrixMult'#1^#(::(@l, @ls), @m2) -> matrixMult'^#(@ls, @m2)
  , matrixMult3^#(@m1, @m2, @m3) ->
    matrixMult^#(matrixMult(@m1, @m2), @m3)
  , matrixMultList^#(@acc, @mm) -> matrixMultList#1^#(@mm, @acc)
  , matrixMultList#1^#(::(@m, @ms), @acc) -> matrixMult^#(@acc, @m)
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    matrixMultList^#(matrixMult(@acc, @m), @ms)
  , matrixMultOld^#(@m1, @m2) -> matrixMult'^#(@m1, transpose(@m2)) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { lineMult#1^#(::(@x, @xs), @l) ->
    c_2(mult^#(@l, @x), lineMult^#(@l, @xs)) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).

Strict DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs)) }
Weak DPs:
  { matrixMult^#(@m1, @m2) ->
    c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))
  , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_9(matrixMult^#(@acc, @m))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))
  , matrixMultOld^#(@m1, @m2) ->
    c_11(matrixMult'^#(@m1, transpose(@m2))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^1))

We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.

DPs:
  { 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
  , 3: matrixMult^#(@m1, @m2) ->
       c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , 9: matrixMultList#1^#(::(@m, @ms), @acc) ->
       c_9(matrixMult^#(@acc, @m))
  , 10: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_10(matrixMultList^#(matrixMult(@acc, @m), @ms)) }
Trs:
  { attach#2(nil(), @x, @xs) -> nil()
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
    Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1},
    Uargs(c_10) = {1}, Uargs(c_11) = {1}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA) and not(IDA(1)).
  
                            [#0] = [0]
                                   [0]
                                      
                      [#abs](x1) = [0]
                                   [0]
                                      
                      [#neg](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                      [#pos](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                        [#s](x1) = [0 1] x1 + [0]
                                   [0 1]      [0]
                                                 
                     [*](x1, x2) = [0]
                                   [0]
                                      
                 [#mult](x1, x2) = [0]
                                   [0]
                                      
                     [+](x1, x2) = [0]
                                   [0]
                                      
                  [#add](x1, x2) = [1 0] x2 + [0]
                                   [1 1]      [0]
                                                 
                [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
              [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
                    [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
          [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1]
                                   [0 1]      [0 0]      [0 0]      [0]
                                                                       
                           [nil] = [0]
                                   [0]
                                      
              [lineMult](x1, x2) = [1 0] x1 + [0 1] x2 + [1]
                                   [0 0]      [0 0]      [0]
                                                            
            [lineMult#1](x1, x2) = [0 1] x1 + [1]
                                   [1 1]      [0]
                                                 
                  [mult](x1, x2) = [0 0] x1 + [1]
                                   [1 0]      [0]
                                                 
                  [makeBase](x1) = [1 1] x1 + [1]
                                   [1 1]      [0]
                                                 
                [makeBase#1](x1) = [0 1] x1 + [1]
                                   [1 1]      [0]
                                                 
                    [mkBase](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
            [matrixMult](x1, x2) = [1 0] x1 + [0]
                                   [1 0]      [0]
                                                 
              [transAcc](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
           [matrixMult'](x1, x2) = [1 0] x1 + [1]
                                   [1 0]      [0]
                                                 
         [matrixMult'#1](x1, x2) = [0 0] x1 + [1 0] x2 + [0]
                                   [1 0]      [0 1]      [0]
                                                            
                 [transpose](x1) = [1 1] x1 + [0]
                                   [1 0]      [1]
                                                 
                  [mkBase#1](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                [mult#1](x1, x2) = [0]
                                   [0]
                                      
            [mult#2](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [0]
                                   [1 0]      [0 1]      [0]
                                                            
                     [split](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                   [split#1](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
               [split#2](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
               [tuple#2](x1, x2) = [1 0] x1 + [1 1] x2 + [0]
                                   [0 1]      [0 0]      [0]
                                                            
           [split#3](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1]
                                   [0 1]      [0 0]      [0 0]      [1]
                                                                       
            [transAcc#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
           [transpose#1](x1, x2) = [1 1] x2 + [0]
                                   [1 0]      [1]
                                                 
               [transpose#2](x1) = [1 1] x1 + [0]
                                   [1 0]      [1]
                                                 
           [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [0]
                                   [1 1]      [0 0]      [1]
                                                            
                     [#pred](x1) = [0]
                                   [0]
                                      
                     [#succ](x1) = [0]
                                   [0]
                                      
              [#natmult](x1, x2) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
               [#natadd](x1, x2) = [0 0] x2 + [0]
                                   [0 1]      [0]
                                                 
                    [#abs^#](x1) = [0]
                                   [0]
                                      
                   [*^#](x1, x2) = [0]
                                   [0]
                                      
               [#mult^#](x1, x2) = [0]
                                   [0]
                                      
                   [+^#](x1, x2) = [0]
                                   [0]
                                      
                [#add^#](x1, x2) = [0]
                                   [0]
                                      
              [attach^#](x1, x2) = [0]
                                   [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                   [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
            [lineMult^#](x1, x2) = [0 1] x2 + [0]
                                   [1 1]      [1]
                                                 
          [lineMult#1^#](x1, x2) = [0 1] x1 + [0]
                                   [1 0]      [1]
                                                 
                [mult^#](x1, x2) = [0]
                                   [0]
                                      
              [mult#1^#](x1, x2) = [0]
                                   [0]
                                      
                [makeBase^#](x1) = [0]
                                   [0]
                                      
              [makeBase#1^#](x1) = [0]
                                   [0]
                                      
                  [mkBase^#](x1) = [0]
                                   [0]
                                      
                [mkBase#1^#](x1) = [0]
                                   [0]
                                      
          [matrixMult^#](x1, x2) = [1 1] x2 + [1]
                                   [0 0]      [0]
                                                 
         [matrixMult'^#](x1, x2) = [0 1] x2 + [0]
                                   [0 0]      [0]
                                                 
            [transAcc^#](x1, x2) = [0]
                                   [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMult'#1^#](x1, x2) = [0 0] x1 + [0 1] x2 + [0]
                                   [1 0]      [1 1]      [0]
                                                            
     [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1]
                                   [1 1]      [1 1]      [1 1]      [1]
                                                                       
      [matrixMultList^#](x1, x2) = [1 1] x2 + [1]
                                   [0 0]      [0]
                                                 
    [matrixMultList#1^#](x1, x2) = [1 1] x1 + [1]
                                   [0 1]      [1]
                                                 
       [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 0] x2 + [1]
                                   [1 1]      [1 1]      [1]
                                                            
               [transpose^#](x1) = [0]
                                   [0]
                                      
         [transpose#1^#](x1, x2) = [0]
                                   [0]
                                      
          [mult#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
                   [split^#](x1) = [0]
                                   [0]
                                      
                 [split#1^#](x1) = [0]
                                   [0]
                                      
             [split#2^#](x1, x2) = [0]
                                   [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                   [0]
                                      
             [transpose#2^#](x1) = [0]
                                   [0]
                                      
         [transpose#3^#](x1, x2) = [0]
                                   [0]
                                      
              [transpose'^#](x1) = [0]
                                   [0]
                                      
            [#natmult^#](x1, x2) = [0]
                                   [0]
                                      
                   [#pred^#](x1) = [0]
                                   [0]
                                      
                   [#succ^#](x1) = [0]
                                   [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                   [c_2](x1, x2) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [1 0] x1 + [0]
                                   [0 0]      [1]
                                                 
                       [c_2](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_3](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_4](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_5](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_6](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_7](x1) = [1 0] x1 + [0]
                                   [0 0]      [1]
                                                 
                       [c_8](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_9](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_10](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_11](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
  
  This order satisfies following ordering constraints
  
                        [attach(@line, @m)] =  [1 1] @line + [1 0] @m + [0]                           
                                               [0 0]         [0 1]      [0]                           
                                            >= [1 1] @line + [1 0] @m + [0]                           
                                               [0 0]         [0 1]      [0]                           
                                            =  [attach#1(@line, @m)]                                  
                                                                                                      
                [attach#1(::(@x, @xs), @m)] =  [1 0] @m + [1 1] @x + [1 1] @xs + [1]                  
                                               [0 1]      [0 0]      [0 0]       [0]                  
                                            >= [1 0] @m + [1 1] @x + [1 1] @xs + [1]                  
                                               [0 1]      [0 0]      [0 0]       [0]                  
                                            =  [attach#2(@m, @x, @xs)]                                
                                                                                                      
                      [attach#1(nil(), @m)] =  [1 0] @m + [0]                                         
                                               [0 1]      [0]                                         
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
           [attach#2(::(@l, @ls), @x, @xs)] =  [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1]      
                                               [0 0]      [0 1]       [0 0]      [0 0]       [1]      
                                            >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1]      
                                               [0 0]      [0 1]       [0 0]      [0 0]       [1]      
                                            =  [::(::(@x, @l), attach(@xs, @ls))]                     
                                                                                                      
                 [attach#2(nil(), @x, @xs)] =  [1 1] @x + [1 1] @xs + [1]                             
                                               [0 0]      [0 0]       [0]                             
                                            >  [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                             [makeBase(@m)] =  [1 1] @m + [1]                                         
                                               [1 1]      [0]                                         
                                            >= [0 1] @m + [1]                                         
                                               [1 1]      [0]                                         
                                            =  [makeBase#1(@m)]                                       
                                                                                                      
                  [makeBase#1(::(@l, @m'))] =  [0 0] @l + [0 1] @m' + [2]                             
                                               [1 1]      [1 1]       [1]                             
                                            >  [0 0] @l + [0]                                         
                                               [0 1]      [0]                                         
                                            =  [mkBase(@l)]                                           
                                                                                                      
                        [makeBase#1(nil())] =  [1]                                                    
                                               [0]                                                    
                                            >  [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                               [mkBase(@m)] =  [0 0] @m + [0]                                         
                                               [0 1]      [0]                                         
                                            >= [0 0] @m + [0]                                         
                                               [0 1]      [0]                                         
                                            =  [mkBase#1(@m)]                                         
                                                                                                      
                      [transAcc(@m, @base)] =  [1 0] @base + [1 0] @m + [0]                           
                                               [0 1]         [0 0]      [0]                           
                                            >= [1 0] @base + [1 0] @m + [0]                           
                                               [0 1]         [0 0]      [0]                           
                                            =  [transAcc#1(@m, @base)]                                
                                                                                                      
                            [transpose(@m)] =  [1 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            >= [1 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            =  [transpose#1(@m, @m)]                                  
                                                                                                      
                    [mkBase#1(::(@l, @m'))] =  [0 0] @m' + [0]                                        
                                               [0 1]       [1]                                        
                                            >= [0 0] @m' + [0]                                        
                                               [0 1]       [1]                                        
                                            =  [::(nil(), mkBase(@m'))]                               
                                                                                                      
                          [mkBase#1(nil())] =  [0]                                                    
                                               [0]                                                    
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                                [split(@m)] =  [1 0] @m + [0]                                         
                                               [0 1]      [0]                                         
                                            >= [1 0] @m + [0]                                         
                                               [0 1]      [0]                                         
                                            =  [split#1(@m)]                                          
                                                                                                      
                     [split#1(::(@l, @ls))] =  [1 1] @l + [1 0] @ls + [0]                             
                                               [0 0]      [0 1]       [1]                             
                                            >= [1 1] @l + [1 0] @ls + [0]                             
                                               [0 0]      [0 1]       [1]                             
                                            =  [split#2(@l, @ls)]                                     
                                                                                                      
                           [split#1(nil())] =  [0]                                                    
                                               [0]                                                    
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [tuple#2(nil(), nil())]                                
                                                                                                      
                [split#2(::(@x, @xs), @ls)] =  [1 0] @ls + [1 1] @x + [1 1] @xs + [1]                 
                                               [0 1]       [0 0]      [0 0]       [1]                 
                                            >= [1 0] @ls + [1 1] @x + [1 1] @xs + [1]                 
                                               [0 1]       [0 0]      [0 0]       [1]                 
                                            =  [split#3(split(@ls), @x, @xs)]                         
                                                                                                      
                      [split#2(nil(), @ls)] =  [1 0] @ls + [0]                                        
                                               [0 1]       [1]                                        
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [tuple#2(nil(), nil())]                                
                                                                                                      
      [split#3(tuple#2(@ys, @m'), @x, @xs)] =  [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1]     
                                               [0 0]       [0 0]      [0 0]       [0 1]       [1]     
                                            >= [1 1] @m' + [1 1] @x + [1 1] @xs + [1 0] @ys + [1]     
                                               [0 0]       [0 0]      [0 0]       [0 1]       [1]     
                                            =  [tuple#2(::(@x, @ys), ::(@xs, @m'))]                   
                                                                                                      
           [transAcc#1(::(@l, @m'), @base)] =  [1 0] @base + [1 1] @l + [1 0] @m' + [0]               
                                               [0 1]         [0 0]      [0 0]       [0]               
                                            >= [1 0] @base + [1 1] @l + [1 0] @m' + [0]               
                                               [0 1]         [0 0]      [0 0]       [0]               
                                            =  [attach(@l, transAcc(@m', @base))]                     
                                                                                                      
                 [transAcc#1(nil(), @base)] =  [1 0] @base + [0]                                      
                                               [0 1]         [0]                                      
                                            >= [1 0] @base + [0]                                      
                                               [0 1]         [0]                                      
                                            =  [@base]                                                
                                                                                                      
           [transpose#1(::(@xs, @xss), @m)] =  [1 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            >= [1 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            =  [transpose#2(split(@m))]                               
                                                                                                      
                   [transpose#1(nil(), @m)] =  [1 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
            [transpose#2(tuple#2(@l, @m'))] =  [1 1] @l + [1 1] @m' + [0]                             
                                               [1 0]      [1 1]       [1]                             
                                            >= [1 1] @l + [1 1] @m' + [0]                             
                                               [0 0]      [1 1]       [1]                             
                                            =  [transpose#3(@m', @l)]                                 
                                                                                                      
             [transpose#3(::(@y, @ys), @l)] =  [1 1] @l + [1 1] @y + [1 1] @ys + [1]                  
                                               [0 0]      [1 1]      [1 1]       [2]                  
                                            >= [1 1] @l + [1 1] @y + [1 1] @ys + [1]                  
                                               [0 0]      [1 1]      [1 0]       [2]                  
                                            =  [::(@l, transpose(::(@y, @ys)))]                       
                                                                                                      
                   [transpose#3(nil(), @l)] =  [1 1] @l + [0]                                         
                                               [0 0]      [1]                                         
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                      [lineMult^#(@l, @m2)] =  [0 1] @m2 + [0]                                        
                                               [1 1]       [1]                                        
                                            >= [0 1] @m2 + [0]                                        
                                               [0 0]       [1]                                        
                                            =  [c_1(lineMult#1^#(@m2, @l))]                           
                                                                                                      
            [lineMult#1^#(::(@x, @xs), @l)] =  [0 0] @x + [0 1] @xs + [1]                             
                                               [1 1]      [1 0]       [1]                             
                                            >  [0 1] @xs + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_2(lineMult^#(@l, @xs))]                             
                                                                                                      
                   [matrixMult^#(@m1, @m2)] =  [1 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            >  [1 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))]
                                                                                                      
                  [matrixMult'^#(@m1, @m2)] =  [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            >= [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_4(matrixMult'#1^#(@m1, @m2))]                       
                                                                                                      
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0 0] @l + [0 0] @ls + [0 1] @m2 + [0]                 
                                               [1 1]      [1 0]       [1 1]       [0]                 
                                            >= [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_5(lineMult^#(@l, @m2))]                             
                                                                                                      
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0 0] @l + [0 0] @ls + [0 1] @m2 + [0]                 
                                               [1 1]      [1 0]       [1 1]       [0]                 
                                            >= [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_6(matrixMult'^#(@ls, @m2))]                         
                                                                                                      
             [matrixMult3^#(@m1, @m2, @m3)] =  [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1]                
                                               [1 1]       [1 1]       [1 1]       [1]                
                                            >= [1 1] @m3 + [1]                                        
                                               [0 0]       [1]                                        
                                            =  [c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))]         
                                                                                                      
              [matrixMultList^#(@acc, @mm)] =  [1 1] @mm + [1]                                        
                                               [0 0]       [0]                                        
                                            >= [1 1] @mm + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_8(matrixMultList#1^#(@mm, @acc))]                   
                                                                                                      
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1 1] @m + [1 1] @ms + [2]                             
                                               [0 0]      [0 1]       [2]                             
                                            >  [1 1] @m + [1]                                         
                                               [0 0]      [0]                                         
                                            =  [c_9(matrixMult^#(@acc, @m))]                          
                                                                                                      
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [1 1] @m + [1 1] @ms + [2]                             
                                               [0 0]      [0 1]       [2]                             
                                            >  [1 1] @ms + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))]    
                                                                                                      
                [matrixMultOld^#(@m1, @m2)] =  [1 0] @m1 + [1 0] @m2 + [1]                            
                                               [1 1]       [1 1]       [1]                            
                                            >= [1 0] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_11(matrixMult'^#(@m1, transpose(@m2)))]             
                                                                                                      

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
  , 3: matrixMult^#(@m1, @m2) ->
       c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , 4: matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2))
  , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
  , 6: matrixMult'#1^#(::(@l, @ls), @m2) ->
       c_6(matrixMult'^#(@ls, @m2))
  , 7: matrixMult3^#(@m1, @m2, @m3) ->
       c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))
  , 8: matrixMultList^#(@acc, @mm) ->
       c_8(matrixMultList#1^#(@mm, @acc))
  , 9: matrixMultList#1^#(::(@m, @ms), @acc) ->
       c_9(matrixMult^#(@acc, @m))
  , 10: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))
  , 11: matrixMultOld^#(@m1, @m2) ->
        c_11(matrixMult'^#(@m1, transpose(@m2))) }

Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {2,3,9,10}. These cover all (indirect) predecessors of
dependency pairs {2,3,7,8,9,10,11}, their number of application is
equally bounded. The dependency pairs are shifted into the
corresponding weak component(s).


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).

Strict DPs: { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l)) }
Weak DPs:
  { lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
  , matrixMult^#(@m1, @m2) ->
    c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))
  , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_9(matrixMult^#(@acc, @m))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))
  , matrixMultOld^#(@m1, @m2) ->
    c_11(matrixMult'^#(@m1, transpose(@m2))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^1))

We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.

DPs:
  { 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
  , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
  , 9: matrixMultList#1^#(::(@m, @ms), @acc) ->
       c_9(matrixMult^#(@acc, @m)) }
Trs:
  { attach#2(nil(), @x, @xs) -> nil()
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , makeBase(@m) -> makeBase#1(@m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transpose#1(nil(), @m) -> nil()
  , transpose#3(nil(), @l) -> nil() }

Sub-proof:
----------
  The following argument positions are usable:
    Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
    Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
    Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1},
    Uargs(c_10) = {1}, Uargs(c_11) = {1}
  
  TcT has computed following constructor-based matrix interpretation
  satisfying not(EDA) and not(IDA(1)).
  
                            [#0] = [0]
                                   [0]
                                      
                      [#abs](x1) = [0 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                      [#neg](x1) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
                      [#pos](x1) = [1 0] x1 + [0]
                                   [0 1]      [0]
                                                 
                        [#s](x1) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
                     [*](x1, x2) = [0]
                                   [0]
                                      
                 [#mult](x1, x2) = [0]
                                   [0]
                                      
                     [+](x1, x2) = [1 0] x2 + [0]
                                   [0 0]      [0]
                                                 
                  [#add](x1, x2) = [1 0] x2 + [0]
                                   [1 1]      [0]
                                                 
                [attach](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
              [attach#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [0]
                                                            
                    [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [0 1]      [1]
                                                            
          [attach#2](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1]
                                   [0 1]      [0 0]      [0 0]      [0]
                                                                       
                           [nil] = [0]
                                   [0]
                                      
              [lineMult](x1, x2) = [0 0] x1 + [0 0] x2 + [0]
                                   [1 0]      [1 0]      [0]
                                                            
            [lineMult#1](x1, x2) = [0 1] x1 + [1 0] x2 + [0]
                                   [1 0]      [1 0]      [1]
                                                            
                  [mult](x1, x2) = [0]
                                   [0]
                                      
                  [makeBase](x1) = [1 0] x1 + [1]
                                   [1 0]      [0]
                                                 
                [makeBase#1](x1) = [1 0] x1 + [0]
                                   [1 0]      [0]
                                                 
                    [mkBase](x1) = [0 1] x1 + [0]
                                   [1 1]      [0]
                                                 
            [matrixMult](x1, x2) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
              [transAcc](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 1]      [0 1]      [0]
                                                            
           [matrixMult'](x1, x2) = [0 0] x1 + [0]
                                   [1 1]      [0]
                                                 
         [matrixMult'#1](x1, x2) = [0 0] x1 + [1 0] x2 + [0]
                                   [1 1]      [0 1]      [0]
                                                            
                 [transpose](x1) = [1 1] x1 + [1]
                                   [1 1]      [0]
                                                 
                  [mkBase#1](x1) = [0 1] x1 + [0]
                                   [1 1]      [0]
                                                 
                [mult#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 0]      [1 0]      [0]
                                                            
            [mult#2](x1, x2, x3) = [0 0] x2 + [0 0] x3 + [0]
                                   [1 1]      [1 1]      [0]
                                                            
                     [split](x1) = [0 1] x1 + [0]
                                   [1 0]      [1]
                                                 
                   [split#1](x1) = [0 1] x1 + [0]
                                   [1 0]      [1]
                                                 
               [split#2](x1, x2) = [0 0] x1 + [0 1] x2 + [1]
                                   [1 1]      [1 0]      [1]
                                                            
               [tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0]
                                   [1 0]      [1 1]      [1]
                                                            
           [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0 0] x3 + [1]
                                   [0 1]      [1 1]      [1 1]      [1]
                                                                       
            [transAcc#1](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                   [0 1]      [0 1]      [0]
                                                            
           [transpose#1](x1, x2) = [0 0] x1 + [1 1] x2 + [1]
                                   [0 1]      [1 0]      [0]
                                                            
               [transpose#2](x1) = [1 1] x1 + [0]
                                   [0 1]      [0]
                                                 
           [transpose#3](x1, x2) = [1 1] x1 + [1 1] x2 + [1]
                                   [1 1]      [0 0]      [1]
                                                            
                     [#pred](x1) = [0]
                                   [0]
                                      
                     [#succ](x1) = [0]
                                   [0]
                                      
              [#natmult](x1, x2) = [0]
                                   [0]
                                      
               [#natadd](x1, x2) = [0]
                                   [0]
                                      
                    [#abs^#](x1) = [0]
                                   [0]
                                      
                   [*^#](x1, x2) = [0]
                                   [0]
                                      
               [#mult^#](x1, x2) = [0]
                                   [0]
                                      
                   [+^#](x1, x2) = [0]
                                   [0]
                                      
                [#add^#](x1, x2) = [0]
                                   [0]
                                      
              [attach^#](x1, x2) = [0]
                                   [0]
                                      
            [attach#1^#](x1, x2) = [0]
                                   [0]
                                      
        [attach#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
            [lineMult^#](x1, x2) = [0 1] x2 + [0]
                                   [0 0]      [0]
                                                 
          [lineMult#1^#](x1, x2) = [0 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                [mult^#](x1, x2) = [0]
                                   [0]
                                      
              [mult#1^#](x1, x2) = [0]
                                   [0]
                                      
                [makeBase^#](x1) = [0]
                                   [0]
                                      
              [makeBase#1^#](x1) = [0]
                                   [0]
                                      
                  [mkBase^#](x1) = [0]
                                   [0]
                                      
                [mkBase#1^#](x1) = [0]
                                   [0]
                                      
          [matrixMult^#](x1, x2) = [1 1] x2 + [1]
                                   [0 0]      [0]
                                                 
         [matrixMult'^#](x1, x2) = [0 0] x1 + [0 1] x2 + [1]
                                   [1 1]      [0 0]      [0]
                                                            
            [transAcc^#](x1, x2) = [0]
                                   [0]
                                      
          [transAcc#1^#](x1, x2) = [0]
                                   [0]
                                      
       [matrixMult'#1^#](x1, x2) = [0 1] x2 + [1]
                                   [0 0]      [0]
                                                 
     [matrixMult3^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 1] x3 + [1]
                                   [1 1]      [1 1]      [1 1]      [1]
                                                                       
      [matrixMultList^#](x1, x2) = [1 1] x2 + [1]
                                   [0 0]      [0]
                                                 
    [matrixMultList#1^#](x1, x2) = [1 1] x1 + [0 0] x2 + [1]
                                   [0 0]      [1 1]      [0]
                                                            
       [matrixMultOld^#](x1, x2) = [1 0] x1 + [1 1] x2 + [1]
                                   [1 1]      [1 1]      [1]
                                                            
               [transpose^#](x1) = [0]
                                   [0]
                                      
         [transpose#1^#](x1, x2) = [0]
                                   [0]
                                      
          [mult#2^#](x1, x2, x3) = [0]
                                   [0]
                                      
                   [split^#](x1) = [0]
                                   [0]
                                      
                 [split#1^#](x1) = [0]
                                   [0]
                                      
             [split#2^#](x1, x2) = [0]
                                   [0]
                                      
         [split#3^#](x1, x2, x3) = [0]
                                   [0]
                                      
             [transpose#2^#](x1) = [0]
                                   [0]
                                      
         [transpose#3^#](x1, x2) = [0]
                                   [0]
                                      
              [transpose'^#](x1) = [0]
                                   [0]
                                      
            [#natmult^#](x1, x2) = [0]
                                   [0]
                                      
                   [#pred^#](x1) = [0]
                                   [0]
                                      
                   [#succ^#](x1) = [0]
                                   [0]
                                      
             [#natadd^#](x1, x2) = [0]
                                   [0]
                                      
                       [c_1](x1) = [0]
                                   [0]
                                      
                   [c_2](x1, x2) = [0]
                                   [0]
                                      
                       [c_3](x1) = [0]
                                   [0]
                                      
                       [c_4](x1) = [0]
                                   [0]
                                      
                       [c_7](x1) = [0]
                                   [0]
                                      
                             [c] = [0]
                                   [0]
                                      
                       [c_1](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_2](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_3](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_4](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_5](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_6](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_7](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_8](x1) = [1 0] x1 + [0]
                                   [0 0]      [0]
                                                 
                       [c_9](x1) = [1 1] x1 + [0]
                                   [0 0]      [0]
                                                 
                      [c_10](x1) = [1 0] x1 + [1]
                                   [0 0]      [0]
                                                 
                      [c_11](x1) = [1 0] x1 + [0]
                                   [0 0]      [1]
  
  This order satisfies following ordering constraints
  
                        [attach(@line, @m)] =  [1 1] @line + [1 0] @m + [0]                           
                                               [0 0]         [0 1]      [0]                           
                                            >= [1 1] @line + [1 0] @m + [0]                           
                                               [0 0]         [0 1]      [0]                           
                                            =  [attach#1(@line, @m)]                                  
                                                                                                      
                [attach#1(::(@x, @xs), @m)] =  [1 0] @m + [1 1] @x + [1 1] @xs + [1]                  
                                               [0 1]      [0 0]      [0 0]       [0]                  
                                            >= [1 0] @m + [1 1] @x + [1 1] @xs + [1]                  
                                               [0 1]      [0 0]      [0 0]       [0]                  
                                            =  [attach#2(@m, @x, @xs)]                                
                                                                                                      
                      [attach#1(nil(), @m)] =  [1 0] @m + [0]                                         
                                               [0 1]      [0]                                         
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
           [attach#2(::(@l, @ls), @x, @xs)] =  [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1]      
                                               [0 0]      [0 1]       [0 0]      [0 0]       [1]      
                                            >= [1 1] @l + [1 0] @ls + [1 1] @x + [1 1] @xs + [1]      
                                               [0 0]      [0 1]       [0 0]      [0 0]       [1]      
                                            =  [::(::(@x, @l), attach(@xs, @ls))]                     
                                                                                                      
                 [attach#2(nil(), @x, @xs)] =  [1 1] @x + [1 1] @xs + [1]                             
                                               [0 0]      [0 0]       [0]                             
                                            >  [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                             [makeBase(@m)] =  [1 0] @m + [1]                                         
                                               [1 0]      [0]                                         
                                            >  [1 0] @m + [0]                                         
                                               [1 0]      [0]                                         
                                            =  [makeBase#1(@m)]                                       
                                                                                                      
                  [makeBase#1(::(@l, @m'))] =  [1 1] @l + [1 0] @m' + [0]                             
                                               [1 1]      [1 0]       [0]                             
                                            >= [0 1] @l + [0]                                         
                                               [1 1]      [0]                                         
                                            =  [mkBase(@l)]                                           
                                                                                                      
                        [makeBase#1(nil())] =  [0]                                                    
                                               [0]                                                    
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                               [mkBase(@m)] =  [0 1] @m + [0]                                         
                                               [1 1]      [0]                                         
                                            >= [0 1] @m + [0]                                         
                                               [1 1]      [0]                                         
                                            =  [mkBase#1(@m)]                                         
                                                                                                      
                      [transAcc(@m, @base)] =  [1 0] @base + [1 1] @m + [0]                           
                                               [0 1]         [0 1]      [0]                           
                                            >= [1 0] @base + [1 1] @m + [0]                           
                                               [0 1]         [0 1]      [0]                           
                                            =  [transAcc#1(@m, @base)]                                
                                                                                                      
                            [transpose(@m)] =  [1 1] @m + [1]                                         
                                               [1 1]      [0]                                         
                                            >= [1 1] @m + [1]                                         
                                               [1 1]      [0]                                         
                                            =  [transpose#1(@m, @m)]                                  
                                                                                                      
                    [mkBase#1(::(@l, @m'))] =  [0 0] @l + [0 1] @m' + [1]                             
                                               [1 1]      [1 1]       [1]                             
                                            >  [0 1] @m' + [0]                                        
                                               [1 1]       [1]                                        
                                            =  [::(nil(), mkBase(@m'))]                               
                                                                                                      
                          [mkBase#1(nil())] =  [0]                                                    
                                               [0]                                                    
                                            >= [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                                [split(@m)] =  [0 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            >= [0 1] @m + [0]                                         
                                               [1 0]      [1]                                         
                                            =  [split#1(@m)]                                          
                                                                                                      
                     [split#1(::(@l, @ls))] =  [0 0] @l + [0 1] @ls + [1]                             
                                               [1 1]      [1 0]       [1]                             
                                            >= [0 0] @l + [0 1] @ls + [1]                             
                                               [1 1]      [1 0]       [1]                             
                                            =  [split#2(@l, @ls)]                                     
                                                                                                      
                           [split#1(nil())] =  [0]                                                    
                                               [1]                                                    
                                            >= [0]                                                    
                                               [1]                                                    
                                            =  [tuple#2(nil(), nil())]                                
                                                                                                      
                [split#2(::(@x, @xs), @ls)] =  [0 1] @ls + [0 0] @x + [0 0] @xs + [1]                 
                                               [1 0]       [1 1]      [1 1]       [2]                 
                                            >= [0 1] @ls + [0 0] @x + [0 0] @xs + [1]                 
                                               [1 0]       [1 1]      [1 1]       [2]                 
                                            =  [split#3(split(@ls), @x, @xs)]                         
                                                                                                      
                      [split#2(nil(), @ls)] =  [0 1] @ls + [1]                                        
                                               [1 0]       [1]                                        
                                            >  [0]                                                    
                                               [1]                                                    
                                            =  [tuple#2(nil(), nil())]                                
                                                                                                      
      [split#3(tuple#2(@ys, @m'), @x, @xs)] =  [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1]     
                                               [1 1]       [1 1]      [1 1]       [1 0]       [2]     
                                            >= [0 0] @m' + [0 0] @x + [0 0] @xs + [0 1] @ys + [1]     
                                               [1 1]       [1 1]      [1 1]       [1 0]       [2]     
                                            =  [tuple#2(::(@x, @ys), ::(@xs, @m'))]                   
                                                                                                      
           [transAcc#1(::(@l, @m'), @base)] =  [1 0] @base + [1 1] @l + [1 1] @m' + [1]               
                                               [0 1]         [0 0]      [0 1]       [1]               
                                            >  [1 0] @base + [1 1] @l + [1 1] @m' + [0]               
                                               [0 1]         [0 0]      [0 1]       [0]               
                                            =  [attach(@l, transAcc(@m', @base))]                     
                                                                                                      
                 [transAcc#1(nil(), @base)] =  [1 0] @base + [0]                                      
                                               [0 1]         [0]                                      
                                            >= [1 0] @base + [0]                                      
                                               [0 1]         [0]                                      
                                            =  [@base]                                                
                                                                                                      
           [transpose#1(::(@xs, @xss), @m)] =  [1 1] @m + [0 0] @xss + [1]                            
                                               [1 0]      [0 1]        [1]                            
                                            >= [1 1] @m + [1]                                         
                                               [1 0]      [1]                                         
                                            =  [transpose#2(split(@m))]                               
                                                                                                      
                   [transpose#1(nil(), @m)] =  [1 1] @m + [1]                                         
                                               [1 0]      [0]                                         
                                            >  [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
            [transpose#2(tuple#2(@l, @m'))] =  [1 1] @l + [1 1] @m' + [1]                             
                                               [1 0]      [1 1]       [1]                             
                                            >= [1 1] @l + [1 1] @m' + [1]                             
                                               [0 0]      [1 1]       [1]                             
                                            =  [transpose#3(@m', @l)]                                 
                                                                                                      
             [transpose#3(::(@y, @ys), @l)] =  [1 1] @l + [1 1] @y + [1 1] @ys + [2]                  
                                               [0 0]      [1 1]      [1 1]       [2]                  
                                            >= [1 1] @l + [1 1] @y + [1 1] @ys + [2]                  
                                               [0 0]      [1 1]      [1 1]       [2]                  
                                            =  [::(@l, transpose(::(@y, @ys)))]                       
                                                                                                      
                   [transpose#3(nil(), @l)] =  [1 1] @l + [1]                                         
                                               [0 0]      [1]                                         
                                            >  [0]                                                    
                                               [0]                                                    
                                            =  [nil()]                                                
                                                                                                      
                      [lineMult^#(@l, @m2)] =  [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            >= [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_1(lineMult#1^#(@m2, @l))]                           
                                                                                                      
            [lineMult#1^#(::(@x, @xs), @l)] =  [0 1] @xs + [1]                                        
                                               [0 0]       [0]                                        
                                            >  [0 1] @xs + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_2(lineMult^#(@l, @xs))]                             
                                                                                                      
                   [matrixMult^#(@m1, @m2)] =  [1 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            >= [1 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))]
                                                                                                      
                  [matrixMult'^#(@m1, @m2)] =  [0 0] @m1 + [0 1] @m2 + [1]                            
                                               [1 1]       [0 0]       [0]                            
                                            >= [0 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_4(matrixMult'#1^#(@m1, @m2))]                       
                                                                                                      
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            >  [0 1] @m2 + [0]                                        
                                               [0 0]       [0]                                        
                                            =  [c_5(lineMult^#(@l, @m2))]                             
                                                                                                      
        [matrixMult'#1^#(::(@l, @ls), @m2)] =  [0 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            >= [0 1] @m2 + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_6(matrixMult'^#(@ls, @m2))]                         
                                                                                                      
             [matrixMult3^#(@m1, @m2, @m3)] =  [1 0] @m1 + [1 0] @m2 + [1 1] @m3 + [1]                
                                               [1 1]       [1 1]       [1 1]       [1]                
                                            >= [1 1] @m3 + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))]         
                                                                                                      
              [matrixMultList^#(@acc, @mm)] =  [1 1] @mm + [1]                                        
                                               [0 0]       [0]                                        
                                            >= [1 1] @mm + [1]                                        
                                               [0 0]       [0]                                        
                                            =  [c_8(matrixMultList#1^#(@mm, @acc))]                   
                                                                                                      
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [0 0] @acc + [1 1] @m + [1 1] @ms + [2]                
                                               [1 1]        [0 0]      [0 0]       [0]                
                                            >  [1 1] @m + [1]                                         
                                               [0 0]      [0]                                         
                                            =  [c_9(matrixMult^#(@acc, @m))]                          
                                                                                                      
    [matrixMultList#1^#(::(@m, @ms), @acc)] =  [0 0] @acc + [1 1] @m + [1 1] @ms + [2]                
                                               [1 1]        [0 0]      [0 0]       [0]                
                                            >= [1 1] @ms + [2]                                        
                                               [0 0]       [0]                                        
                                            =  [c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))]    
                                                                                                      
                [matrixMultOld^#(@m1, @m2)] =  [1 0] @m1 + [1 1] @m2 + [1]                            
                                               [1 1]       [1 1]       [1]                            
                                            >= [1 1] @m2 + [1]                                        
                                               [0 0]       [1]                                        
                                            =  [c_11(matrixMult'^#(@m1, transpose(@m2)))]             
                                                                                                      

Consider the set of all dependency pairs

DPs:
  { 1: lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , 2: lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
  , 3: matrixMult^#(@m1, @m2) ->
       c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , 4: matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2))
  , 5: matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
  , 6: matrixMult'#1^#(::(@l, @ls), @m2) ->
       c_6(matrixMult'^#(@ls, @m2))
  , 7: matrixMult3^#(@m1, @m2, @m3) ->
       c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))
  , 8: matrixMultList^#(@acc, @mm) ->
       c_8(matrixMultList#1^#(@mm, @acc))
  , 9: matrixMultList#1^#(::(@m, @ms), @acc) ->
       c_9(matrixMult^#(@acc, @m))
  , 10: matrixMultList#1^#(::(@m, @ms), @acc) ->
        c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))
  , 11: matrixMultOld^#(@m1, @m2) ->
        c_11(matrixMult'^#(@m1, transpose(@m2))) }

Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {2,5,9}. These cover all (indirect) predecessors of
dependency pairs {1,2,3,5,7,9,11}, their number of application is
equally bounded. The dependency pairs are shifted into the
corresponding weak component(s).

We apply the transformation 'removetails' on the sub-problem:

Weak DPs:
  { lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
  , lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
  , matrixMult^#(@m1, @m2) ->
    c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
  , matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
  , matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2))
  , matrixMult3^#(@m1, @m2, @m3) ->
    c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))
  , matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_9(matrixMult^#(@acc, @m))
  , matrixMultList#1^#(::(@m, @ms), @acc) ->
    c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))
  , matrixMultOld^#(@m1, @m2) ->
    c_11(matrixMult'^#(@m1, transpose(@m2))) }
Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ lineMult^#(@l, @m2) -> c_1(lineMult#1^#(@m2, @l))
, lineMult#1^#(::(@x, @xs), @l) -> c_2(lineMult^#(@l, @xs))
, matrixMult^#(@m1, @m2) ->
  c_3(matrixMult'^#(@m1, transAcc(@m2, makeBase(@m2))))
, matrixMult'^#(@m1, @m2) -> c_4(matrixMult'#1^#(@m1, @m2))
, matrixMult'#1^#(::(@l, @ls), @m2) -> c_5(lineMult^#(@l, @m2))
, matrixMult'#1^#(::(@l, @ls), @m2) -> c_6(matrixMult'^#(@ls, @m2))
, matrixMult3^#(@m1, @m2, @m3) ->
  c_7(matrixMult^#(matrixMult(@m1, @m2), @m3))
, matrixMultList^#(@acc, @mm) -> c_8(matrixMultList#1^#(@mm, @acc))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
  c_9(matrixMult^#(@acc, @m))
, matrixMultList#1^#(::(@m, @ms), @acc) ->
  c_10(matrixMultList^#(matrixMult(@acc, @m), @ms))
, matrixMultOld^#(@m1, @m2) ->
  c_11(matrixMult'^#(@m1, transpose(@m2))) }


We apply the transformation 'usablerules' on the sub-problem:

Weak Trs:
  { #abs(#0()) -> #0()
  , #abs(#neg(@x)) -> #pos(@x)
  , #abs(#pos(@x)) -> #pos(@x)
  , #abs(#s(@x)) -> #pos(#s(@x))
  , *(@x, @y) -> #mult(@x, @y)
  , #mult(#0(), #0()) -> #0()
  , #mult(#0(), #neg(@y)) -> #0()
  , #mult(#0(), #pos(@y)) -> #0()
  , #mult(#neg(@x), #0()) -> #0()
  , #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
  , #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #0()) -> #0()
  , #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
  , #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
  , +(@x, @y) -> #add(@x, @y)
  , #add(#0(), @y) -> @y
  , #add(#neg(#s(#0())), @y) -> #pred(@y)
  , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
  , #add(#pos(#s(#0())), @y) -> #succ(@y)
  , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
  , attach(@line, @m) -> attach#1(@line, @m)
  , attach#1(::(@x, @xs), @m) -> attach#2(@m, @x, @xs)
  , attach#1(nil(), @m) -> nil()
  , attach#2(::(@l, @ls), @x, @xs) ->
    ::(::(@x, @l), attach(@xs, @ls))
  , attach#2(nil(), @x, @xs) -> nil()
  , lineMult(@l, @m2) -> lineMult#1(@m2, @l)
  , lineMult#1(::(@x, @xs), @l) ->
    ::(mult(@l, @x), lineMult(@l, @xs))
  , lineMult#1(nil(), @l) -> nil()
  , mult(@l1, @l2) -> mult#1(@l1, @l2)
  , makeBase(@m) -> makeBase#1(@m)
  , makeBase#1(::(@l, @m')) -> mkBase(@l)
  , makeBase#1(nil()) -> nil()
  , mkBase(@m) -> mkBase#1(@m)
  , matrixMult(@m1, @m2) ->
    matrixMult'(@m1, transAcc(@m2, makeBase(@m2)))
  , transAcc(@m, @base) -> transAcc#1(@m, @base)
  , matrixMult'(@m1, @m2) -> matrixMult'#1(@m1, @m2)
  , matrixMult'#1(::(@l, @ls), @m2) ->
    ::(lineMult(@l, @m2), matrixMult'(@ls, @m2))
  , matrixMult'#1(nil(), @m2) -> nil()
  , transpose(@m) -> transpose#1(@m, @m)
  , mkBase#1(::(@l, @m')) -> ::(nil(), mkBase(@m'))
  , mkBase#1(nil()) -> nil()
  , mult#1(::(@x, @xs), @l2) -> mult#2(@l2, @x, @xs)
  , mult#1(nil(), @l2) -> #abs(#0())
  , mult#2(::(@y, @ys), @x, @xs) -> +(*(@x, @y), mult(@xs, @ys))
  , mult#2(nil(), @x, @xs) -> #abs(#0())
  , split(@m) -> split#1(@m)
  , split#1(::(@l, @ls)) -> split#2(@l, @ls)
  , split#1(nil()) -> tuple#2(nil(), nil())
  , split#2(::(@x, @xs), @ls) -> split#3(split(@ls), @x, @xs)
  , split#2(nil(), @ls) -> tuple#2(nil(), nil())
  , split#3(tuple#2(@ys, @m'), @x, @xs) ->
    tuple#2(::(@x, @ys), ::(@xs, @m'))
  , transAcc#1(::(@l, @m'), @base) ->
    attach(@l, transAcc(@m', @base))
  , transAcc#1(nil(), @base) -> @base
  , transpose#1(::(@xs, @xss), @m) -> transpose#2(split(@m))
  , transpose#1(nil(), @m) -> nil()
  , transpose#2(tuple#2(@l, @m')) -> transpose#3(@m', @l)
  , transpose#3(::(@y, @ys), @l) -> ::(@l, transpose(::(@y, @ys)))
  , transpose#3(nil(), @l) -> nil()
  , #pred(#0()) -> #neg(#s(#0()))
  , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
  , #pred(#pos(#s(#0()))) -> #0()
  , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
  , #succ(#0()) -> #pos(#s(#0()))
  , #succ(#neg(#s(#0()))) -> #0()
  , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
  , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))
  , #natmult(#0(), @y) -> #0()
  , #natmult(#s(@x), @y) -> #natadd(@y, #natmult(@x, @y))
  , #natadd(#0(), @y) -> @y
  , #natadd(#s(@x), @y) -> #s(#natadd(@x, @y)) }
StartTerms: basic terms
Strategy: innermost

No rule is usable, rules are removed from the input problem.


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).

Rules: Empty
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(1))

Empty rules are trivially bounded

Wall-time: 2.637302s
CPU-time: 18.238s

Wall-time: 1.316066s
CPU-time: 8.383s

Wall-time: 72.211023s
CPU-time: 605.189s

Hurray, we answered YES(O(1),O(n^3))